Recherche avancée

Médias (0)

Mot : - Tags -/navigation

Aucun média correspondant à vos critères n’est disponible sur le site.

Autres articles (83)

  • Emballe médias : à quoi cela sert ?

    4 février 2011, par

    Ce plugin vise à gérer des sites de mise en ligne de documents de tous types.
    Il crée des "médias", à savoir : un "média" est un article au sens SPIP créé automatiquement lors du téléversement d’un document qu’il soit audio, vidéo, image ou textuel ; un seul document ne peut être lié à un article dit "média" ;

  • Gestion de la ferme

    2 mars 2010, par

    La ferme est gérée dans son ensemble par des "super admins".
    Certains réglages peuvent être fais afin de réguler les besoins des différents canaux.
    Dans un premier temps il utilise le plugin "Gestion de mutualisation"

  • La gestion des forums

    3 novembre 2011, par

    Si les forums sont activés sur le site, les administrateurs ont la possibilité de les gérer depuis l’interface d’administration ou depuis l’article même dans le bloc de modification de l’article qui se trouve dans la navigation de la page.
    Accès à l’interface de modération des messages
    Lorsqu’il est identifié sur le site, l’administrateur peut procéder de deux manières pour gérer les forums.
    S’il souhaite modifier (modérer, déclarer comme SPAM un message) les forums d’un article particulier, il a à sa (...)

Sur d’autres sites (6225)

  • FFMPEG RTSP stream to MPEG4/H264 file using libx264

    4 décembre 2016, par Phi

    Heyo folks,

    I’m attempting to transcode/remux an RTSP stream in H264 format into a MPEG4 container, containing just the H264 video stream. Basically, webcam output into a MP4 container.

    I can get a poorly coded MP4 produced, using this code :

    // Variables here for demo
    
AVFormatContext * video_file_output_format = nullptr;
    
AVFormatContext * rtsp_format_context = nullptr;
    
AVCodecContext * video_file_codec_context = nullptr;
    
AVCodecContext * rtsp_vidstream_codec_context = nullptr;
    
AVPacket packet = {0};
    
AVStream * video_file_stream = nullptr;
    
AVCodec * rtsp_decoder_codec = nullptr;
    
int errorNum = 0, video_stream_index = 0;
    
std::string outputMP4file = "D:\\somemp4file.mp4";
    

    
// begin
    
AVDictionary * opts = nullptr;
    
av_dict_set(&opts, "rtsp_transport", "tcp", 0);
    

    
if ((errorNum = avformat_open_input(&rtsp_format_context, uriANSI.c_str(), NULL, &opts)) < 0) {
    
    errOut << "Connection failed: avformat_open_input failed with error " << errorNum << ":\r\n" << ErrorRead(errorNum);
    
    TacticalAbort();
    
    return;
    
}
    

    
rtsp_format_context->max_analyze_duration = 50000;
    
if ((errorNum = avformat_find_stream_info(rtsp_format_context, NULL)) < 0) {
    
    errOut << "Connection failed: avformat_find_stream_info failed with error " << errorNum << ":\r\n" << ErrorRead(errorNum);
    
    TacticalAbort();
    
    return;
    
}
    

    
video_stream_index = errorNum = av_find_best_stream(rtsp_format_context, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    

    
if (video_stream_index < 0) {
    
    errOut << "Connection in unexpected state; made a connection, but there was no video stream.\r\n"
    
        "Attempts to find a video stream resulted in error " << errorNum << ": " << ErrorRead(errorNum);
    
    TacticalAbort();
    
    return;
    
}
    

    
rtsp_vidstream_codec_context = rtsp_format_context->streams[video_stream_index]->codec;
    

    
av_init_packet(&packet);
    

    
if (!(video_file_output_format = av_guess_format(NULL, outputMP4file.c_str(),  NULL))) {
    
    TacticalAbort();
    
    throw std::exception("av_guess_format");
    
}
    

    
if (!(rtsp_decoder_codec = avcodec_find_decoder(rtsp_vidstream_codec_context->codec_id))) {
    
    errOut << "Connection failed: connected, but avcodec_find_decoder returned null.\r\n"
    
        "Couldn't find codec with an AV_CODEC_ID value of " << rtsp_vidstream_codec_context->codec_id << ".";
    
    TacticalAbort();
    
    return;
    
}
    

    
video_file_format_context = avformat_alloc_context();
    
video_file_format_context->oformat = video_file_output_format;
    

    
if (strcpy_s(video_file_format_context->filename, sizeof(video_file_format_context->filename), outputMP4file.c_str())) {
    
    errOut << "Couldn't open video file: strcpy_s failed with error " << errno << ".";
    
    std::string log = errOut.str();
    
    TacticalAbort();
    
    throw std::exception("strcpy_s");
    
}
    

    
if (!(video_file_encoder_codec = avcodec_find_encoder(video_file_output_format->video_codec))) {
    
    TacticalAbort();
    
    throw std::exception("avcodec_find_encoder");
    
}
    

    
// MARKER ONE
    

    
if (!outputMP4file.empty() &&
    
    !(video_file_output_format->flags & AVFMT_NOFILE) &&
    
    (errorNum = avio_open2(&video_file_format_context->pb, outputMP4file.c_str(), AVIO_FLAG_WRITE, nullptr, &opts)) < 0) {
    
    errOut << "Couldn't open video file \"" << outputMP4file << "\" for writing : avio_open2 failed with error " << errorNum << ": " << ErrorRead(errorNum);
    
    TacticalAbort();
    
    return;
    
}
    

    
// Create stream in MP4 file
    
if (!(video_file_stream = avformat_new_stream(video_file_format_context, video_file_encoder_codec))) {
    
    TacticalAbort();
    
    return;
    
}
    

    
AVCodecContext * video_file_codec_context = video_file_stream->codec;
    

    
// MARKER TWO
    

    
// error -22/-21 in avio_open2 if this is skipped
    
if ((errorNum = avcodec_copy_context(video_file_codec_context, rtsp_vidstream_codec_context)) != 0) {
    
    TacticalAbort();
    
    throw std::exception("avcodec_copy_context");
    
}
    

    
//video_file_codec_context->codec_tag = 0;
    

    
/*
    
// MARKER 3 - is this not needed? Examples suggest not.
    
if ((errorNum = avcodec_open2(video_file_codec_context, video_file_encoder_codec, &opts)) < 0)
    
{
    
    errOut << "Couldn't open video file codec context: avcodec_open2 failed with error " << errorNum << ": " << ErrorRead(errorNum);
    
    std::string log = errOut.str();
    
    TacticalAbort();
    
    throw std::exception("avcodec_open2, video file");
    
}*/
    

    
//video_file_format_context->flags |= AVFMT_FLAG_GENPTS;
    
if (video_file_format_context->oformat->flags & AVFMT_GLOBALHEADER)
    
{
    
    video_file_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
    
}
    

    
if ((errorNum = avformat_write_header(video_file_format_context, &opts)) < 0) {
    
    errOut << "Couldn't open video file: avformat_write_header failed with error " << errorNum << ":\r\n" << ErrorRead(errorNum);
    
    std::string log = errOut.str();
    
    TacticalAbort();
    
    return;
    
}

    However, there are several issues :

    1. I can’t pass any x264 options to the output file. The output H264 matches the input H264’s profile/level - switching cameras to a different model switches H264 level.
    2. The timing of the output file is off, noticeably.
    3. The duration of the output file is off, massively. A few seconds of footage becomes hours, although playtime doesn’t match. (FWIW, I’m using VLC to play them.)

    Passing x264 options

    If I manually increment PTS per packet, and set DTS equal to PTS, it plays too fast, 2-3 seconds’ worth of footage in one second playtime, and duration is hours long. The footage also blurs past several seconds, about 10 seconds’ footage in a second.

    If I let FFMPEG decide (with or without GENPTS flag), the file has a variable frame rate (probably as expected), but it plays the whole file in an instant and has a long duration too (over forty hours for a few seconds). The duration isn’t "real", as the file plays in an instant.

    At Marker One, I try to set the profile by passing options to avio_open2. The options are simply ignored by libx264. I’ve tried :

    av_dict_set(&opts, "vprofile", "main", 0);
    
av_dict_set(&opts, "profile", "main", 0); // error, missing '('
    
// FF_PROFILE_H264_MAIN equals 77, so I also tried
    
av_dict_set(&opts, "vprofile", "77", 0); 
    
av_dict_set(&opts, "profile", "77", 0);

    It does seem to read the profile setting, but it doesn’t use them. At Marker Two, I tried to set it after the avio_open2, before avformat_write_header .

    // I tried all 4 av_dict_set from earlier, passing it to avformat_write_header.
    
// None had any effect, they weren't consumed.
    
av_opt_set(video_file_codec_context, "profile", "77", 0);
    
av_opt_set(video_file_codec_context, "profile", "main", 0);
    
video_file_codec_context->profile = FF_PROFILE_H264_MAIN;
    
av_opt_set(video_file_codec_context->priv_data, "profile", "77", 0);
    
av_opt_set(video_file_codec_context->priv_data, "profile", "main", 0);

    Messing with privdata made the program unstable, but I was trying anything at that point.
    I’d like to solve issue 1 with passing settings, since I imagine it’d bottleneck any attempt to solve issues 2 or 3.

    I’ve been fiddling with this for the better part of a month now. I’ve been through dozens of documentation, Q&As, examples. It doesn’t help that quite a few are outdated.

    Any help would be appreciated.

    Cheers

  • FFMPEG RTSP stream to MPEG4/H264 file using libx264

    4 décembre 2016, par Phi

    Heyo folks,

    I’m attempting to transcode/remux an RTSP stream in H264 format into a MPEG4 container, containing just the H264 video stream. Basically, webcam output into a MP4 container.

    I can get a poorly coded MP4 produced, using this code :

    // Variables here for demo
    
AVFormatContext * video_file_output_format = nullptr;
    
AVFormatContext * rtsp_format_context = nullptr;
    
AVCodecContext * video_file_codec_context = nullptr;
    
AVCodecContext * rtsp_vidstream_codec_context = nullptr;
    
AVPacket packet = {0};
    
AVStream * video_file_stream = nullptr;
    
AVCodec * rtsp_decoder_codec = nullptr;
    
int errorNum = 0, video_stream_index = 0;
    
std::string outputMP4file = "D:\\somemp4file.mp4";
    

    
// begin
    
AVDictionary * opts = nullptr;
    
av_dict_set(&opts, "rtsp_transport", "tcp", 0);
    

    
if ((errorNum = avformat_open_input(&rtsp_format_context, uriANSI.c_str(), NULL, &opts)) < 0) {
    
    errOut << "Connection failed: avformat_open_input failed with error " << errorNum << ":\r\n" << ErrorRead(errorNum);
    
    TacticalAbort();
    
    return;
    
}
    

    
rtsp_format_context->max_analyze_duration = 50000;
    
if ((errorNum = avformat_find_stream_info(rtsp_format_context, NULL)) < 0) {
    
    errOut << "Connection failed: avformat_find_stream_info failed with error " << errorNum << ":\r\n" << ErrorRead(errorNum);
    
    TacticalAbort();
    
    return;
    
}
    

    
video_stream_index = errorNum = av_find_best_stream(rtsp_format_context, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    

    
if (video_stream_index < 0) {
    
    errOut << "Connection in unexpected state; made a connection, but there was no video stream.\r\n"
    
        "Attempts to find a video stream resulted in error " << errorNum << ": " << ErrorRead(errorNum);
    
    TacticalAbort();
    
    return;
    
}
    

    
rtsp_vidstream_codec_context = rtsp_format_context->streams[video_stream_index]->codec;
    

    
av_init_packet(&packet);
    

    
if (!(video_file_output_format = av_guess_format(NULL, outputMP4file.c_str(),  NULL))) {
    
    TacticalAbort();
    
    throw std::exception("av_guess_format");
    
}
    

    
if (!(rtsp_decoder_codec = avcodec_find_decoder(rtsp_vidstream_codec_context->codec_id))) {
    
    errOut << "Connection failed: connected, but avcodec_find_decoder returned null.\r\n"
    
        "Couldn't find codec with an AV_CODEC_ID value of " << rtsp_vidstream_codec_context->codec_id << ".";
    
    TacticalAbort();
    
    return;
    
}
    

    
video_file_format_context = avformat_alloc_context();
    
video_file_format_context->oformat = video_file_output_format;
    

    
if (strcpy_s(video_file_format_context->filename, sizeof(video_file_format_context->filename), outputMP4file.c_str())) {
    
    errOut << "Couldn't open video file: strcpy_s failed with error " << errno << ".";
    
    std::string log = errOut.str();
    
    TacticalAbort();
    
    throw std::exception("strcpy_s");
    
}
    

    
if (!(video_file_encoder_codec = avcodec_find_encoder(video_file_output_format->video_codec))) {
    
    TacticalAbort();
    
    throw std::exception("avcodec_find_encoder");
    
}
    

    
// MARKER ONE
    

    
if (!outputMP4file.empty() &&
    
    !(video_file_output_format->flags & AVFMT_NOFILE) &&
    
    (errorNum = avio_open2(&video_file_format_context->pb, outputMP4file.c_str(), AVIO_FLAG_WRITE, nullptr, &opts)) < 0) {
    
    errOut << "Couldn't open video file \"" << outputMP4file << "\" for writing : avio_open2 failed with error " << errorNum << ": " << ErrorRead(errorNum);
    
    TacticalAbort();
    
    return;
    
}
    

    
// Create stream in MP4 file
    
if (!(video_file_stream = avformat_new_stream(video_file_format_context, video_file_encoder_codec))) {
    
    TacticalAbort();
    
    return;
    
}
    

    
AVCodecContext * video_file_codec_context = video_file_stream->codec;
    

    
// MARKER TWO
    

    
// error -22/-21 in avio_open2 if this is skipped
    
if ((errorNum = avcodec_copy_context(video_file_codec_context, rtsp_vidstream_codec_context)) != 0) {
    
    TacticalAbort();
    
    throw std::exception("avcodec_copy_context");
    
}
    

    
//video_file_codec_context->codec_tag = 0;
    

    
/*
    
// MARKER 3 - is this not needed? Examples suggest not.
    
if ((errorNum = avcodec_open2(video_file_codec_context, video_file_encoder_codec, &opts)) < 0)
    
{
    
    errOut << "Couldn't open video file codec context: avcodec_open2 failed with error " << errorNum << ": " << ErrorRead(errorNum);
    
    std::string log = errOut.str();
    
    TacticalAbort();
    
    throw std::exception("avcodec_open2, video file");
    
}*/
    

    
//video_file_format_context->flags |= AVFMT_FLAG_GENPTS;
    
if (video_file_format_context->oformat->flags & AVFMT_GLOBALHEADER)
    
{
    
    video_file_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
    
}
    

    
if ((errorNum = avformat_write_header(video_file_format_context, &opts)) < 0) {
    
    errOut << "Couldn't open video file: avformat_write_header failed with error " << errorNum << ":\r\n" << ErrorRead(errorNum);
    
    std::string log = errOut.str();
    
    TacticalAbort();
    
    return;
    
}

    However, there are several issues :

    1. I can’t pass any x264 options to the output file. The output H264 matches the input H264’s profile/level - switching cameras to a different model switches H264 level.
    2. The timing of the output file is off, noticeably.
    3. The duration of the output file is off, massively. A few seconds of footage becomes hours, although playtime doesn’t match. (FWIW, I’m using VLC to play them.)

    Passing x264 options

    If I manually increment PTS per packet, and set DTS equal to PTS, it plays too fast, 2-3 seconds’ worth of footage in one second playtime, and duration is hours long. The footage also blurs past several seconds, about 10 seconds’ footage in a second.

    If I let FFMPEG decide (with or without GENPTS flag), the file has a variable frame rate (probably as expected), but it plays the whole file in an instant and has a long duration too (over forty hours for a few seconds). The duration isn’t "real", as the file plays in an instant.

    At Marker One, I try to set the profile by passing options to avio_open2. The options are simply ignored by libx264. I’ve tried :

    av_dict_set(&opts, "vprofile", "main", 0);
    
av_dict_set(&opts, "profile", "main", 0); // error, missing '('
    
// FF_PROFILE_H264_MAIN equals 77, so I also tried
    
av_dict_set(&opts, "vprofile", "77", 0); 
    
av_dict_set(&opts, "profile", "77", 0);

    It does seem to read the profile setting, but it doesn’t use them. At Marker Two, I tried to set it after the avio_open2, before avformat_write_header .

    // I tried all 4 av_dict_set from earlier, passing it to avformat_write_header.
    
// None had any effect, they weren't consumed.
    
av_opt_set(video_file_codec_context, "profile", "77", 0);
    
av_opt_set(video_file_codec_context, "profile", "main", 0);
    
video_file_codec_context->profile = FF_PROFILE_H264_MAIN;
    
av_opt_set(video_file_codec_context->priv_data, "profile", "77", 0);
    
av_opt_set(video_file_codec_context->priv_data, "profile", "main", 0);

    Messing with privdata made the program unstable, but I was trying anything at that point.
    I’d like to solve issue 1 with passing settings, since I imagine it’d bottleneck any attempt to solve issues 2 or 3.

    I’ve been fiddling with this for the better part of a month now. I’ve been through dozens of documentation, Q&As, examples. It doesn’t help that quite a few are outdated.

    Any help would be appreciated.

    Cheers

  • Segfault while trying to fill the yuv image for rtsp streaming

    21 septembre 2016, par tankyx

    I am capturing the video stream from a window, and I want to restream it to my rtsp proxy server. However, it seems I can’t write the frame properly, but I can show the said frame in a SDL window. Here is my code :

    int StreamHandler::storeStreamData()
    
{
    
// Allocate video frame
    
pFrame = av_frame_alloc();
    

    
// Allocate an AVFrame structure
    
pFrameRGB = av_frame_alloc();
    
if (pFrameRGB == NULL)
    
    throw myExceptions("Error : Can't alloc the frame.");
    

    
// Determine required buffer size and allocate buffer
    
numBytes = avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx->width,
    
    pCodecCtx->height);
    
buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
    

    
// Assign appropriate parts of buffer to image planes in pFrameRGB
    
avpicture_fill((AVPicture *)pFrameRGB, buffer, AV_PIX_FMT_YUV420P,
    
    pCodecCtx->width, pCodecCtx->height);
    

    
//InitSdlDrawBack();
    

    
// initialize SWS context for software scaling
    

    
sws_ctx = sws_getContext(pCodecCtx->width,
    
    pCodecCtx->height,
    
    pCodecCtx->pix_fmt,
    
    pCodecCtx->width,
    
    pCodecCtx->height,
    
    pCodecCtx->pix_fmt,
    
    SWS_LANCZOS,
    
    NULL,
    
    NULL,
    
    NULL
    
);
    

    
SetPixelArray();
    
FfmpegEncoder enc("rtsp://127.0.0.1:1935/live/myStream");
    

    
i = 0;
    
while (av_read_frame(pFormatCtx, &packet) >= 0) {
    
    if (packet.stream_index == videoindex) {
    
        // Decode video frame
    
        avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
    
        if (frameFinished) {
    
            i++;
    
            //DrawFrame();
    

    
            sws_scale(sws_ctx, (uint8_t const * const *)pFrame->data,
    
                pFrame->linesize, 0, pCodecCtx->height,
    
                pFrameRGB->data, pFrameRGB->linesize);
    
            enc.encodeFrame(pFrameRGB, i);
    
        }
    
    }
    
    // Free the packet that was allocated by av_read_frame
    
    av_free_packet(&packet);
    
}
    
// Free the RGB image
    
av_free(buffer);
    
av_frame_free(&pFrameRGB);
    

    
// Free the YUV frame
    
av_frame_free(&pFrame);
    

    
// Close the codecs
    
avcodec_close(pCodecCtx);
    
avcodec_close(pCodecCtxOrig);
    

    
// Close the video file
    
avformat_close_input(&pFormatCtx);
    

    
return 0;
    
}
    

    
void StreamHandler::SetPixelArray()
    
{
    
yPlaneSz = pCodecCtx->width * pCodecCtx->height;
    
uvPlaneSz = pCodecCtx->width * pCodecCtx->height / 4;
    
yPlane = (Uint8*)malloc(yPlaneSz);
    
uPlane = (Uint8*)malloc(uvPlaneSz);
    
vPlane = (Uint8*)malloc(uvPlaneSz);
    
if (!yPlane || !uPlane || !vPlane)
    
    throw myExceptions("Error : Can't create pixel array.");
    

    
uvPitch = pCodecCtx->width / 2;
    
}

    Here I fill the YUV image and write the packet.

    void FfmpegEncoder::encodeFrame(AVFrame * frame, int frameCount)
    
{
    
AVPacket    pkt = { 0 };
    
int         got_pkt;
    

    
av_init_packet(&pkt);
    
frame->pts = frameCount;
    

    
FillYuvImage(frame, frameCount, this->pCodecCtx->width, this->pCodecCtx->height);
    

    
if (avcodec_encode_video2(this->pCodecCtx, &pkt, frame, &got_pkt) < 0)
    
    throw myExceptions("Error: failed to encode the frame. FfmpegEncoder.cpp l:61\n");
    

    
//if the frame is well encoded
    
if (got_pkt) {
    
    pkt.stream_index = this->st->index;
    
    pkt.pts = av_rescale_q_rnd(pkt.pts, this->pCodecCtx->time_base, this->st->time_base, AVRounding(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
    
    if (av_write_frame(this->outFormatCtx, &pkt) < 0)
    
        throw myExceptions("Error: failed to write video frame. FfmpegEncoder.cpp l:68\n");
    
}
    
}
    

    
void FfmpegEncoder::FillYuvImage(AVFrame * pict, int frame_index, int width, int height)
    
{
    
int x, y, i;
    

    
i = frame_index;
    

    
for (y = 0; y < height; y++)
    
{
    
    for (x = 0; x < width / 2; x++)
    
        pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
    
}
    
for (y = 0; y < height; y++)
    
{
    
    for (x = 0; x < width / 2; x++)
    
    {
    
        pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
    
        pict->data[2][y * pict->linesize[2] + x] = 64 + y + i * 5; //segault here
    
    }
    
}
    
}

    The "FillYuvImage" method is copied from a FFMPEG example, but It does not work for me. If I don’t call it, the "av_write_frame" function won’t work (segfault too).

    EDIT : Here is my output context and codec initialization.

    FfmpegEncoder::FfmpegEncoder(char *url)
    
{
    
AVRational      tmp_time_base;
    
AVDictionary*   options = NULL;
    

    
this->pCodec = avcodec_find_encoder(AV_CODEC_ID_H264);
    
if (this->pCodec == NULL)
    
    throw myExceptions("Error: Can't initialize the encoder. FfmpegEncoder.cpp l:9\n");
    

    
this->pCodecCtx = avcodec_alloc_context3(this->pCodec);
    

    
//Alloc output context
    
if (avformat_alloc_output_context2(&outFormatCtx, NULL, "rtsp", url) < 0)
    
    throw myExceptions("Error: Can't alloc stream output. FfmpegEncoder.cpp l:17\n");
    

    
this->st = avformat_new_stream(this->outFormatCtx, this->pCodec);
    

    
if (this->st == NULL)
    
    throw myExceptions("Error: Can't create stream . FfmpegEncoder.cpp l:22\n");
    

    
av_dict_set(&options, "vprofile", "main", 0);
    
av_dict_set(&options, "tune", "zerolatency", 0);
    

    
tmp_time_base.num = 1;
    
tmp_time_base.den = 60;
    

    
//TODO : parse these values
    
this->pCodecCtx->bit_rate = 3000000;
    
this->pCodecCtx->width = 1280;
    
this->pCodecCtx->height = 720;
    
//This set the fps. 60fps at this point.
    
this->pCodecCtx->time_base = tmp_time_base;
    
//Add a intra frame every 12 frames
    
this->pCodecCtx->gop_size = 12;
    
this->pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
    

    
//Open Codec, using the context + x264 options
    
if (avcodec_open2(this->pCodecCtx, this->pCodec, &options) < 0)
    
    throw myExceptions("Error: Can't open the codec. FfmpegEncoder.cpp l:43\n");
    

    
if (avcodec_copy_context(this->st->codec, this->pCodecCtx) != 0) {
    
    throw myExceptions("Error : Can't copy codec context. FfmpegEncoder.cpp : l.46");
    
}
    

    
av_dump_format(this->outFormatCtx, 0, url, 1);
    

    
if (avformat_write_header(this->outFormatCtx, NULL) != 0)
    
    throw myExceptions("Error: failed to connect to RTSP server. FfmpegEncoder.cpp l:48\n");
    
}

Navigation