Recherche avancée

Médias (1)

Mot : - Tags -/ticket

Autres articles (38)

  • La sauvegarde automatique de canaux SPIP

    1er avril 2010, par

    Dans le cadre de la mise en place d’une plateforme ouverte, il est important pour les hébergeurs de pouvoir disposer de sauvegardes assez régulières pour parer à tout problème éventuel.
    Pour réaliser cette tâche on se base sur deux plugins SPIP : Saveauto qui permet une sauvegarde régulière de la base de donnée sous la forme d’un dump mysql (utilisable dans phpmyadmin) mes_fichiers_2 qui permet de réaliser une archive au format zip des données importantes du site (les documents, les éléments (...)

  • MediaSPIP v0.2

    21 juin 2013, par

    MediaSPIP 0.2 est la première version de MediaSPIP stable.
    Sa date de sortie officielle est le 21 juin 2013 et est annoncée ici.
    Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
    Comme pour la version précédente, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
    Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...)

  • Mise à disposition des fichiers

    14 avril 2011, par

    Par défaut, lors de son initialisation, MediaSPIP ne permet pas aux visiteurs de télécharger les fichiers qu’ils soient originaux ou le résultat de leur transformation ou encodage. Il permet uniquement de les visualiser.
    Cependant, il est possible et facile d’autoriser les visiteurs à avoir accès à ces documents et ce sous différentes formes.
    Tout cela se passe dans la page de configuration du squelette. Il vous faut aller dans l’espace d’administration du canal, et choisir dans la navigation (...)

Sur d’autres sites (4896)

  • Losing quality when encoding with ffmpeg

    22 mai 2016, par lupod

    I am using the c libraries of ffmpeg to read frames from a video and create an output file that is supposed to be identical to the input.
    However, somewhere during this process some quality gets lost and the result is "less sharp". My guess is that the problem is the encoding and that the frames are too compressed (also because the size of the file decreases quite significantly). Is there some parameter in the encoder that allows me to control the quality of the result ? I found that AVCodecContext has a compression_level member, but changing it that does not seem to have any effect.

    I post here part of my code in case it could help. I would say that something must be changed in the init function of OutputVideoBuilder when I set the codec. The AVCodecContext that is passed to the method is the same of InputVideoHandler.
    Here are the two main classes that I created to wrap the ffmpeg functionalities :

    // This class opens the video files and sets the decoder
    
class InputVideoHandler {
    
public:
    
  InputVideoHandler(char* name);
    
  ~InputVideoHandler();
    
  AVCodecContext* getCodecContext();
    
  bool readFrame(AVFrame* frame, int* success);
    

    
private:
    
  InputVideoHandler();
    
  void init(char* name);
    
  AVFormatContext* formatCtx;
    
  AVCodec* codec;
    
  AVCodecContext* codecCtx;
    
  AVPacket packet;
    
  int streamIndex;
    
};
    

    
void InputVideoHandler::init(char* name) {
    
  streamIndex = -1;
    
  int numStreams;
    

    
  if (avformat_open_input(&formatCtx, name, NULL, NULL) != 0)
    
    throw std::exception("Invalid input file name.");
    

    
  if (avformat_find_stream_info(formatCtx, NULL)<0)
    
    throw std::exception("Could not find stream information.");
    

    
  numStreams = formatCtx->nb_streams;
    

    
  if (numStreams < 0)
    
    throw std::exception("No streams in input video file.");
    

    
  for (int i = 0; i < numStreams; i++) {
    
    if (formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
    
      streamIndex = i;
    
      break;
    
    }
    
  }
    

    
  if (streamIndex < 0)
    
    throw std::exception("No video stream in input video file.");
    

    
  // find decoder using id
    
  codec = avcodec_find_decoder(formatCtx->streams[streamIndex]->codec->codec_id);
    
  if (codec == nullptr)
    
    throw std::exception("Could not find suitable decoder for input file.");
    

    
  // copy context from input stream
    
  codecCtx = avcodec_alloc_context3(codec);
    
  if (avcodec_copy_context(codecCtx, formatCtx->streams[streamIndex]->codec) != 0)
    
    throw std::exception("Could not copy codec context from input stream.");
    

    
  if (avcodec_open2(codecCtx, codec, NULL) < 0)
    
    throw std::exception("Could not open decoder.");
    
}
    

    
// frame must be initialized with av_frame_alloc() before!
    
// Returns true if there are other frames, false if not.
    
// success == 1 if frame is valid, 0 if not.
    
bool InputVideoHandler::readFrame(AVFrame* frame, int* success) {
    
  *success = 0;
    
  if (av_read_frame(formatCtx, &packet) < 0)
    
    return false;
    
  if (packet.stream_index == streamIndex) {
    
    avcodec_decode_video2(codecCtx, frame, success, &packet);
    
  }
    
  av_free_packet(&packet);
    
  return true;
    
}
    

    
// This class opens the output and write frames to it
    
class OutputVideoBuilder{
    
public:
    
  OutputVideoBuilder(char* name, AVCodecContext* inputCtx);
    
  ~OutputVideoBuilder();
    
  void writeFrame(AVFrame* frame);
    
  void writeVideo();
    

    
private:
    
  OutputVideoBuilder();
    
  void init(char* name, AVCodecContext* inputCtx);
    
  void logMsg(AVPacket* packet, AVRational* tb);
    
  AVFormatContext* formatCtx;
    
  AVCodec* codec;
    
  AVCodecContext* codecCtx;
    
  AVStream* stream;
    
};
    

    
void OutputVideoBuilder::init(char* name, AVCodecContext* inputCtx) {
    
  if (avformat_alloc_output_context2(&formatCtx, NULL, NULL, name) < 0)
    
    throw std::exception("Could not determine file extension from provided name.");
    

    
  codec = avcodec_find_encoder(inputCtx->codec_id);
    
  if (codec == nullptr) {
    
    throw std::exception("Could not find suitable encoder.");
    
  }
    

    
  codecCtx = avcodec_alloc_context3(codec);
    
  if (avcodec_copy_context(codecCtx, inputCtx) < 0)
    
    throw std::exception("Could not copy output codec context from input");
    

    
  codecCtx->time_base = inputCtx->time_base;
    
  codecCtx->compression_level = 0;
    

    
  if (avcodec_open2(codecCtx, codec, NULL) < 0)
    
    throw std::exception("Could not open encoder.");
    

    
  stream = avformat_new_stream(formatCtx, codec);
    
  if (stream == nullptr) {
    
    throw std::exception("Could not allocate stream.");
    
  }
    

    
  stream->id = formatCtx->nb_streams - 1;
    
  stream->codec = codecCtx;
    
  stream->time_base = codecCtx->time_base;
    

    

    

    
  av_dump_format(formatCtx, 0, name, 1);
    
  if (!(formatCtx->oformat->flags & AVFMT_NOFILE)) {
    
    if (avio_open(&formatCtx->pb, name, AVIO_FLAG_WRITE) < 0) {
    
      throw std::exception("Could not open output file.");
    
    }
    
  }
    

    
  if (avformat_write_header(formatCtx, NULL) < 0) {
    
    throw std::exception("Error occurred when opening output file.");
    
  }
    

    
}
    

    
void OutputVideoBuilder::writeFrame(AVFrame* frame) {
    
  AVPacket packet = { 0 };
    
  int success;
    
  av_init_packet(&packet);
    

    
  if (avcodec_encode_video2(codecCtx, &packet, frame, &success))
    
    throw std::exception("Error encoding frames");
    

    
  if (success) {
    
    av_packet_rescale_ts(&packet, codecCtx->time_base, stream->time_base);
    
    packet.stream_index = stream->index;
    
    logMsg(&packet,&stream->time_base);
    
    av_interleaved_write_frame(formatCtx, &packet);
    
  }
    
  av_free_packet(&packet);
    
}

    This is the part of the main function that reads and write frames :

     while (inputHandler->readFrame(frame,&gotFrame)) {
    

    
    if (gotFrame) {
    
      try {
    
        outputBuilder->writeFrame(frame);
    
      }
    
      catch (std::exception e) {
    
        std::cout << e.what() << std::endl;
    
        return -1;
    
      }
    
    }
    
  }

  • Ffmpeg error "avcodec_send_frame" return "invalid argument"

    17 octobre 2023, par Paulo Coutinho

    I have a problem in function avcodec_send_frame throwing error Error sending frame for encoding: Invalid argument (-22). I already search, check, recheck and nothing. It is near the ffmpeg examples. Can anyone help me ? Thanks.

    


    This is my code :

    


    static void callbackAddSubtitle(const Message &m, const Response r)
{
    try
    {
        av_log_set_level(AV_LOG_DEBUG);

        spdlog::debug("[Mapping :: callbackAddSubtitle] Adding subtitle...");

        auto inputOpt = m.get("input");
        auto outputOpt = m.get("output");

        if (!inputOpt.has_value() || !outputOpt.has_value())
        {
            r(std::string{"INVALID-PARAMS"});
            return;
        }

        const std::string &input = inputOpt.value();
        const std::string &output = outputOpt.value();

        // initialize input
        spdlog::debug("[Mapping :: callbackAddSubtitle] Initializing input video...");

        AVFormatContext *inputFormatCtx = avformat_alloc_context();
        if (avformat_open_input(&inputFormatCtx, input.c_str(), nullptr, nullptr) != 0)
        {
            spdlog::error("Failed to open input");
            r(std::string{"ERROR-OPEN-INPUT"});
            return;
        }

        if (avformat_find_stream_info(inputFormatCtx, nullptr) < 0)
        {
            spdlog::error("Failed to find stream information");
            avformat_close_input(&inputFormatCtx);
            r(std::string{"ERROR-FIND-STREAM"});
            return;
        }

        int videoStreamIndex = av_find_best_stream(inputFormatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
        if (videoStreamIndex < 0)
        {
            spdlog::error("Could not find a video stream");
            r(std::string{"ERROR-FIND-VIDEO-STREAM"});
            return;
        }

        AVRational timeBase = inputFormatCtx->streams[videoStreamIndex]->time_base;

        AVCodecParameters *inputCodecPar = inputFormatCtx->streams[videoStreamIndex]->codecpar;
        const AVCodec *inputCodec = avcodec_find_decoder(inputCodecPar->codec_id);
        AVCodecContext *inputCodecCtx = avcodec_alloc_context3(inputCodec);

        avcodec_parameters_to_context(inputCodecCtx, inputCodecPar);
        avcodec_open2(inputCodecCtx, inputCodec, nullptr);

        // initialize input audio
        spdlog::debug("[Mapping :: callbackAddSubtitle] Initializing input audio...");

        int audioStreamIndex = av_find_best_stream(inputFormatCtx, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);
        if (audioStreamIndex < 0)
        {
            spdlog::error("Could not find an audio stream");
            r(std::string{"ERROR-FIND-AUDIO-STREAM"});
            return;
        }

        AVCodecParameters *inputAudioCodecPar = inputFormatCtx->streams[audioStreamIndex]->codecpar;
        const AVCodec *inputAudioCodec = avcodec_find_decoder(inputAudioCodecPar->codec_id);
        AVCodecContext *inputAudioCodecCtx = avcodec_alloc_context3(inputAudioCodec);

        avcodec_parameters_to_context(inputAudioCodecCtx, inputAudioCodecPar);
        avcodec_open2(inputAudioCodecCtx, inputAudioCodec, nullptr);

        // initialize output video
        spdlog::debug("[Mapping :: callbackAddSubtitle] Initializing output video...");

        AVFormatContext *outputFormatCtx = nullptr;
        avformat_alloc_output_context2(&outputFormatCtx, nullptr, nullptr, output.c_str());
        AVStream *outputStream = avformat_new_stream(outputFormatCtx, nullptr);

        AVCodecContext *outputCodecCtx = avcodec_alloc_context3(inputCodec);
        avcodec_parameters_to_context(outputCodecCtx, inputCodecPar);
        int retOutVideo = avcodec_open2(outputCodecCtx, inputCodec, nullptr);

        if (retOutVideo < 0)
        {
            char err[AV_ERROR_MAX_STRING_SIZE];
            av_make_error_string(err, AV_ERROR_MAX_STRING_SIZE, retOutVideo);
            spdlog::error("Failed to initialize output video: {}", err);
            r(std::string{"ERROR-INIT-OUTPUT-VIDEO"});
            return;
        }

        outputStream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
        outputStream->codecpar->codec_id = inputCodec->id;
        avcodec_parameters_from_context(outputStream->codecpar, outputCodecCtx);

        if (!(outputFormatCtx->oformat->flags & AVFMT_NOFILE))
        {
            avio_open(&outputFormatCtx->pb, output.c_str(), AVIO_FLAG_WRITE);
        }

        const char *pixelFormatName = getPixelFormatName(outputCodecCtx->pix_fmt);
        spdlog::debug("Pixel Format: {}", pixelFormatName);

        // initialize output audio
        spdlog::debug("[Mapping :: callbackAddSubtitle] Initializing output audio...");

        AVStream *outputAudioStream = avformat_new_stream(outputFormatCtx, nullptr);
        AVCodecContext *outputAudioCodecCtx = avcodec_alloc_context3(inputAudioCodec);
        avcodec_parameters_to_context(outputAudioCodecCtx, inputAudioCodecPar);
        int retOutAudio = avcodec_open2(outputAudioCodecCtx, inputAudioCodec, nullptr);

        if (retOutAudio < 0)
        {
            char err[AV_ERROR_MAX_STRING_SIZE];
            av_make_error_string(err, AV_ERROR_MAX_STRING_SIZE, retOutAudio);
            spdlog::error("Failed to initialize output audio: {}", err);
            r(std::string{"ERROR-INIT-OUTPUT-AUDIO"});
            return;
        }

        outputAudioStream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
        outputAudioStream->codecpar->codec_id = inputAudioCodec->id;
        avcodec_parameters_from_context(outputAudioStream->codecpar, outputAudioCodecCtx);

        // initialize filters
        spdlog::debug("[Mapping :: callbackAddSubtitle] Initializing filters...");

        AVFilterGraph *filterGraph = avfilter_graph_alloc();
        if (!filterGraph)
        {
            spdlog::error("Failed to allocate filter graph");
            r(std::string{"ERROR-FILTER-GRAPH"});
            return;
        }

        AVFilterContext *bufferSinkCtx;
        AVFilterContext *bufferSrcCtx;

        const AVFilter *bufferSink = avfilter_get_by_name("buffersink");
        const AVFilter *bufferSrc = avfilter_get_by_name("buffer");

        // input filter
        char filterInArgs[512];
        snprintf(filterInArgs, sizeof(filterInArgs), "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d", inputCodecPar->width, inputCodecPar->height, inputCodecCtx->pix_fmt, timeBase.num, timeBase.den, inputCodecCtx->sample_aspect_ratio.num, inputCodecCtx->sample_aspect_ratio.den);

        spdlog::debug("[Mapping :: callbackAddSubtitle] Buffer src args: {}", filterInArgs);

        int retFilterIn = avfilter_graph_create_filter(&bufferSrcCtx, bufferSrc, "in", filterInArgs, nullptr, filterGraph);
        if (retFilterIn < 0)
        {
            char err[AV_ERROR_MAX_STRING_SIZE];
            av_make_error_string(err, AV_ERROR_MAX_STRING_SIZE, retFilterIn);
            spdlog::error("Failed to create bufferSrcCtx: {}", err);
            r(std::string{"ERROR-CREATE-FILTER-SRC"});
            return;
        }

        // output filter
        int retFilterOut = avfilter_graph_create_filter(&bufferSinkCtx, bufferSink, "out", nullptr, nullptr, filterGraph);

        if (retFilterOut < 0)
        {
            char err[AV_ERROR_MAX_STRING_SIZE];
            av_make_error_string(err, AV_ERROR_MAX_STRING_SIZE, retFilterOut);
            spdlog::error("Failed to create bufferSinkCtx: {}", err);
            r(std::string{"ERROR-CREATE-FILTER-SINK"});
            return;
        }

        enum AVPixelFormat pix_fmts[] = {AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE};
        av_opt_set_int_list(bufferSinkCtx, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);

        // add filters to graph and link them
        const char *filterSpec = "drawtext=text='Legenda Adicionada Automaticamente Via FFMPEG e C++': fontcolor=yellow: bordercolor=black: fontfile='/Users/paulo/Downloads/roboto/Roboto-Black.ttf'";
        const AVFilter *filter = avfilter_get_by_name("drawtext");

        AVFilterInOut *outputs = avfilter_inout_alloc();
        AVFilterInOut *inputs = avfilter_inout_alloc();

        outputs->name = av_strdup("in");
        outputs->filter_ctx = bufferSrcCtx;
        outputs->pad_idx = 0;
        outputs->next = nullptr;
        inputs->name = av_strdup("out");
        inputs->filter_ctx = bufferSinkCtx;
        inputs->pad_idx = 0;
        inputs->next = nullptr;

        if (avfilter_graph_parse_ptr(filterGraph, filterSpec, &inputs, &outputs, nullptr) < 0)
        {
            spdlog::error("Failed to parse filter graph");
            r(std::string{"ERROR-PARSE-FILTER"});
            return;
        }

        if (avfilter_graph_config(filterGraph, nullptr) < 0)
        {
            spdlog::error("Failed to configure filter graph");
            r(std::string{"ERROR-CONFIG-FILTER"});
            return;
        }

        // header
        spdlog::debug("[Mapping :: callbackAddSubtitle] Writing header...");

        if (avformat_write_header(outputFormatCtx, nullptr) < 0)
        {
            spdlog::error("Error writing header");
            r(std::string{"ERROR-WRITE-HEADER"});
            return;
        }

        // read frames and write to output
        AVPacket *packet = av_packet_alloc();
        AVFrame *frame = av_frame_alloc();

        frame->format = inputCodecCtx->pix_fmt;
        frame->width = inputCodecCtx->width;
        frame->height = inputCodecCtx->height;

        AVFrame *filt_frame = av_frame_alloc();

        filt_frame->format = inputCodecCtx->pix_fmt;
        filt_frame->width = inputCodecCtx->width;
        filt_frame->height = inputCodecCtx->height;

        while (av_read_frame(inputFormatCtx, packet) >= 0)
        {
            if (packet->stream_index == videoStreamIndex)
            {
                if (avcodec_send_packet(inputCodecCtx, packet) < 0)
                {
                    spdlog::error("Error sending packet for decoding");
                    r(std::string{"ERROR-SEND-PACKET-DECODE"});
                    return;
                }

                while (avcodec_receive_frame(inputCodecCtx, frame) == 0)
                {
                    // Envia o quadro decodificado para o gráfico de filtro
                    if (av_buffersrc_add_frame_flags(bufferSrcCtx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0)
                    {
                        spdlog::error("Error while feeding the filtergraph");
                        r(std::string{"ERROR-FEED-FILTERGRAPH"});
                        return;
                    }

                    // Recebe um quadro do gráfico de filtro
                    if (av_buffersink_get_frame(bufferSinkCtx, filt_frame) < 0)
                    {
                        spdlog::error("Error while receiving the filtered frame");
                        r(std::string{"ERROR-RECEIVE-FILTERED-FRAME"});
                        return;
                    }

                    // Envia o quadro decodificado para re-codificação
                    int retSendFrame = avcodec_send_frame(outputCodecCtx, filt_frame);
                    if (retSendFrame < 0)
                    {
                        char err[AV_ERROR_MAX_STRING_SIZE];
                        av_make_error_string(err, AV_ERROR_MAX_STRING_SIZE, retSendFrame);
                        spdlog::error("Error sending frame for encoding: {}", err);
                        r(std::string{"ERROR-SEND-FRAME-ENCODE"});
                        return;
                    }

                    AVPacket *output_packet = av_packet_alloc();
                    output_packet->data = nullptr;
                    output_packet->size = 0;

                    // Re-codifica filt_frame para um pacote
                    if (avcodec_receive_packet(outputCodecCtx, output_packet) == 0)
                    {
                        // Escreve o pacote no fluxo de saída
                        av_write_frame(outputFormatCtx, output_packet);
                        av_packet_unref(output_packet);
                    }

                    av_frame_unref(filt_frame);
                }

                // time
                packet->pts = av_rescale_q_rnd(packet->pts, inputFormatCtx->streams[videoStreamIndex]->time_base, outputFormatCtx->streams[videoStreamIndex]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
                packet->dts = av_rescale_q_rnd(packet->dts, inputFormatCtx->streams[videoStreamIndex]->time_base, outputFormatCtx->streams[videoStreamIndex]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
                packet->duration = av_rescale_q(packet->duration, inputFormatCtx->streams[videoStreamIndex]->time_base, outputFormatCtx->streams[videoStreamIndex]->time_base);
                packet->stream_index = videoStreamIndex;

                // write packet to output video stream
                av_interleaved_write_frame(outputFormatCtx, packet);
            }
            else if (packet->stream_index == audioStreamIndex)
            {
                // rescale timestamps
                packet->pts = av_rescale_q_rnd(packet->pts, inputFormatCtx->streams[audioStreamIndex]->time_base, outputFormatCtx->streams[audioStreamIndex]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
                packet->dts = av_rescale_q_rnd(packet->dts, inputFormatCtx->streams[audioStreamIndex]->time_base, outputFormatCtx->streams[audioStreamIndex]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
                packet->duration = av_rescale_q(packet->duration, inputFormatCtx->streams[audioStreamIndex]->time_base, outputFormatCtx->streams[audioStreamIndex]->time_base);
                packet->stream_index = audioStreamIndex;

                // write packet to output audio stream
                av_interleaved_write_frame(outputFormatCtx, packet);
            }

            av_packet_unref(packet);
        }

        av_packet_free(&packet);
        av_frame_free(&frame);
        av_frame_free(&filt_frame);

        spdlog::debug("[Mapping :: callbackAddSubtitle] Writing trailer...");

        if (av_write_trailer(outputFormatCtx) < 0)
        {
            spdlog::error("Error writing trailer");
            r(std::string{"ERROR-WRITE-TRAILER"});
            return;
        }

        // cleanup
        spdlog::debug("[Mapping :: callbackAddSubtitle] Cleaning...");

        if (!(outputFormatCtx->oformat->flags & AVFMT_NOFILE))
        {
            avio_closep(&outputFormatCtx->pb);
        }

        avcodec_free_context(&inputCodecCtx);
        avcodec_free_context(&inputAudioCodecCtx);
        avcodec_free_context(&outputCodecCtx);
        avcodec_free_context(&outputAudioCodecCtx);

        avformat_free_context(inputFormatCtx);
        avformat_free_context(outputFormatCtx);

        r(std::string{"OK"});
    }
    catch (const std::exception &e)
    {
        spdlog::error("Error: {}", e.what());
        r(std::string{"ERROR"});
    }
}


    


    The error is :

    


    [2023-10-17 06:30:16.936] [debug] [Mapping :: callbackAddSubtitle] Adding subtitle...
[2023-10-17 06:30:16.936] [debug] [Mapping :: callbackAddSubtitle] Initializing input video...
[NULL @ 0x153604a60] Opening '/Users/paulo/Downloads/movie.mp4' for reading
[file @ 0x6000001fd170] Setting default whitelist 'file,crypto,data'
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] Format mov,mp4,m4a,3gp,3g2,mj2 probed with size=2048 and score=100
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] ISO: File Type Major Brand: isom
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] Unknown dref type 0x206c7275 size 12
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] Processing st: 0, edit list 0 - media time: 0, duration: 2669670
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] Unknown dref type 0x206c7275 size 12
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] Processing st: 1, edit list 0 - media time: 1024, duration: 4272096
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] drop a frame at curr_cts: 0 @ 0
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] Before avformat_find_stream_info() pos: 113542488 bytes read:110788 seeks:1 nb_streams:2
[h264 @ 0x153604cd0] nal_unit_type: 7(SPS), nal_ref_idc: 3
[h264 @ 0x153604cd0] Decoding VUI
[h264 @ 0x153604cd0] nal_unit_type: 8(PPS), nal_ref_idc: 3
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] demuxer injecting skip 1024 / discard 0
[aac @ 0x1536056f0] skip 1024 / discard 0 samples due to side data
[h264 @ 0x153604cd0] nal_unit_type: 7(SPS), nal_ref_idc: 3
[h264 @ 0x153604cd0] Decoding VUI
[h264 @ 0x153604cd0] nal_unit_type: 8(PPS), nal_ref_idc: 3
[h264 @ 0x153604cd0] nal_unit_type: 6(SEI), nal_ref_idc: 0
[h264 @ 0x153604cd0] nal_unit_type: 5(IDR), nal_ref_idc: 3
[h264 @ 0x153604cd0] Format yuv420p chosen by get_format().
[h264 @ 0x153604cd0] Reinit context to 1088x1920, pix_fmt: yuv420p
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] All info found
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x153604a60] After avformat_find_stream_info() pos: 195211 bytes read:305951 seeks:2 frames:2
[2023-10-17 06:30:18.160] [debug] [Mapping :: callbackAddSubtitle] Initializing input audio...
[h264 @ 0x143604330] nal_unit_type: 7(SPS), nal_ref_idc: 3
[h264 @ 0x143604330] Decoding VUI
[h264 @ 0x143604330] nal_unit_type: 8(PPS), nal_ref_idc: 3
[2023-10-17 06:30:18.160] [debug] [Mapping :: callbackAddSubtitle] Initializing output video...
[h264 @ 0x143611ec0] nal_unit_type: 7(SPS), nal_ref_idc: 3
[h264 @ 0x143611ec0] Decoding VUI
[h264 @ 0x143611ec0] nal_unit_type: 8(PPS), nal_ref_idc: 3
[file @ 0x6000001f4000] Setting default whitelist 'file,crypto,data'
[2023-10-17 06:30:18.167] [debug] Pixel Format: YUV420P
[2023-10-17 06:30:18.167] [debug] [Mapping :: callbackAddSubtitle] Initializing output audio...
[2023-10-17 06:30:18.167] [debug] [Mapping :: callbackAddSubtitle] Initializing filters...
[2023-10-17 06:30:18.168] [debug] [Mapping :: callbackAddSubtitle] Buffer src args: video_size=1080x1920:pix_fmt=0:time_base=1/30000:pixel_aspect=1/1
detected 10 logical cores
[in @ 0x6000004ec0b0] Setting 'video_size' to value '1080x1920'
[in @ 0x6000004ec0b0] Setting 'pix_fmt' to value '0'
[in @ 0x6000004ec0b0] Setting 'time_base' to value '1/30000'
[in @ 0x6000004ec0b0] Setting 'pixel_aspect' to value '1/1'
[in @ 0x6000004ec0b0] w:1080 h:1920 pixfmt:yuv420p tb:1/30000 fr:0/1 sar:1/1
[AVFilterGraph @ 0x6000017e8000] Setting 'text' to value 'Legenda Adicionada Automaticamente Via FFMPEG e C++'
[AVFilterGraph @ 0x6000017e8000] Setting 'fontcolor' to value 'yellow'
[AVFilterGraph @ 0x6000017e8000] Setting 'bordercolor' to value 'black'
[AVFilterGraph @ 0x6000017e8000] Setting 'fontfile' to value '/Users/paulo/Downloads/roboto/Roboto-Black.ttf'
[AVFilterGraph @ 0x6000017e8000] query_formats: 3 queried, 2 merged, 0 already done, 0 delayed
[2023-10-17 06:30:18.172] [debug] [Mapping :: callbackAddSubtitle] Writing header...
[h264 @ 0x143604330] nal_unit_type: 6(SEI), nal_ref_idc: 0
[h264 @ 0x143604330] nal_unit_type: 5(IDR), nal_ref_idc: 3
[h264 @ 0x143604330] Format yuv420p chosen by get_format().
[h264 @ 0x143604330] Reinit context to 1088x1920, pix_fmt: yuv420p
[Parsed_drawtext_0 @ 0x6000004f4160] Copying data in avfilter.
[Parsed_drawtext_0 @ 0x6000004f4160] n:0 t:0.000000 text_w:424 text_h:16 x:0 y:0
[2023-10-17 06:30:18.182] [error] Error sending frame for encoding: Invalid argument
Returned Value: ERROR-SEND-FRAME-ENCODE


    


  • WARN : Tried to pass invalid video frame, marking as broken : Your frame has data type int64, but we require uint8

    5 septembre 2019, par Tavo Diaz

    I am doing some Udemy AI courses and came across with one that "teaches" a bidimensional cheetah how to walk. I was doing the exercises on my computer, but it takes too much time. I decided to use Google Cloud to run the code and see the results some hours after. Nevertheless, when I run the code I get the following error " WARN : Tried to pass
    invalid video frame, marking as broken : Your frame has data type int64, but we require uint8 (i.e. RGB values from 0-255)".

    After the code is executed, I see into the folder and I don’t see any videos (just the meta info).

    Some more info (if it helps) :
    I have a 1 CPU (4g), SSD Ubuntu 16.04 LTS

    I have not tried anything yet to solve it because I don´t know what to try. Im looking for solutions on the web, but nothing I could try.

    This is the code

    import os 
    
import numpy as np
    
import gym
    
from gym import wrappers
    
import pybullet_envs
    

    

    
class Hp():
    
    def __init__(self):
    
        self.nb_steps = 1000
    
        self.episode_lenght =   1000
    
        self.learning_rate = 0.02
    
        self.nb_directions = 32
    
        self.nb_best_directions = 32
    
        assert self.nb_best_directions <= self.nb_directions
    
        self.noise = 0.03
    
        self.seed = 1
    
        self.env_name = 'HalfCheetahBulletEnv-v0'
    

    

    
class Normalizer():
    
    def __init__(self, nb_inputs):
    
        self.n = np.zeros(nb_inputs)
    
        self.mean = np.zeros(nb_inputs)
    
        self.mean_diff = np.zeros(nb_inputs)
    
        self.var = np.zeros(nb_inputs)
    

    
    def observe(self, x):
    
        self.n += 1.
    
        last_mean = self.mean.copy()
    
        self.mean += (x - self.mean) / self.n
    
        #abajo es el online numerator update
    
        self.mean_diff += (x - last_mean) * (x - self.mean)
    
        #abajo online computation de la varianza
    
        self.var = (self.mean_diff / self.n).clip(min = 1e-2)  
    

    
    def normalize(self, inputs):
    
        obs_mean = self.mean
    
        obs_std = np.sqrt(self.var)
    
        return (inputs - obs_mean) / obs_std
    

    
class Policy():
    
    def __init__(self, input_size, output_size):
    
        self.theta = np.zeros((output_size, input_size))
    

    
    def evaluate(self, input, delta = None, direction = None):
    
        if direction is None:
    
            return self.theta.dot(input)
    
        elif direction == 'positive':
    
            return (self.theta + hp.noise * delta).dot(input)
    
        else:
    
            return (self.theta - hp.noise * delta).dot(input)
    

    
    def sample_deltas(self):
    
        return [np.random.randn(*self.theta.shape) for _ in range(hp.nb_directions)]
    

    
    def update (self, rollouts, sigma_r):
    
        step = np.zeros(self.theta.shape)
    
        for r_pos, r_neg, d in rollouts:
    
            step += (r_pos - r_neg) * d
    
        self.theta += hp.learning_rate / (hp.nb_best_directions * sigma_r) * step
    

    

    
def explore(env, normalizer, policy, direction = None, delta = None):
    
    state = env.reset()
    
    done = False
    
    num_plays = 0.
    
    #abajo puede ser promedio de las rewards
    
    sum_rewards = 0
    
    while not done and num_plays < hp.episode_lenght:
    
        normalizer.observe(state)
    
        state = normalizer.normalize(state)
    
        action = policy.evaluate(state, delta, direction)
    
        state, reward, done, _ = env.step(action)
    
        reward = max(min(reward, 1), -1)
    
        #abajo sería poner un promedio
    
        sum_rewards += reward
    
        num_plays += 1
    
    return sum_rewards
    

    
def train (env, policy, normalizer, hp):
    
    for step in range(hp.nb_steps):
    
        #iniciar las perturbaciones deltas y los rewards positivos/negativos
    
        deltas = policy.sample_deltas()
    
        positive_rewards = [0] * hp.nb_directions
    
        negative_rewards = [0] * hp.nb_directions
    
        #sacar las rewards en la dirección positiva
    
        for k in range(hp.nb_directions):
    
            positive_rewards[k] = explore(env, normalizer, policy, direction = 'positive', delta = deltas[k])
    
        #sacar las rewards en dirección negativo
    
        for k in range(hp.nb_directions):
    
            negative_rewards[k] = explore(env, normalizer, policy, direction = 'negative', delta = deltas[k])
    
        #sacar todas las rewards para sacar la desvest
    
        all_rewards = np.array(positive_rewards + negative_rewards)
    
        sigma_r = all_rewards.std()
    
        #acomodar los rollauts por el max (r_pos, r_neg) y seleccionar la mejor dirección
    
        scores = {k:max(r_pos, r_neg) for k, (r_pos, r_neg) in enumerate(zip(positive_rewards, negative_rewards))}
    
        order = sorted(scores.keys(), key = lambda x:scores[x])[:hp.nb_best_directions]
    
        rollouts = [(positive_rewards[k], negative_rewards[k], deltas[k]) for k in order]
    
        #actualizar policy
    
        policy.update (rollouts, sigma_r)
    
        #poner el final reward del policy luego del update
    
        reward_evaluation = explore (env, normalizer, policy)
    
        print('Paso: ', step, 'Lejania: ', reward_evaluation)
    

    
def mkdir(base, name):
    
    path = os.path.join(base, name)
    
    if not os.path.exists(path):
    
        os.makedirs(path)
    
    return path
    
work_dir = mkdir('exp', 'brs')
    
monitor_dir = mkdir(work_dir, 'monitor')
    

    
hp = Hp()
    
np.random.seed(hp.seed)
    
env = gym.make(hp.env_name)
    
env = wrappers.Monitor(env, monitor_dir, force = True)
    
nb_inputs = env.observation_space.shape[0]
    
nb_outputs = env.action_space.shape[0]
    
policy = Policy(nb_inputs, nb_outputs)
    
normalizer = Normalizer(nb_inputs)
    
train(env, policy, normalizer, hp)

Navigation