Wie zum codieren eines video aus mehreren Bildern generiert, die in einem C++ - Programm ohne separaten Rahmen, Bilder auf die Festplatte?

Nach einigen intensiven Kampf habe ich es endlich geschafft, es zu machen, arbeiten nach dem lernen ein bisschen wie die FFmpeg und libx264 C-APIs für meinen spezifischen Zweck, Dank der nützlichen Informationen, die einige Benutzer in dieser Website und einige andere, sowie einige, die FFmpeg Dokumentation Beispiele. Für die illustration, die details werden im folgenden vorgestellt.

Zunächst die libx264-C-Bibliothek kompiliert wurde, und, danach, die FFmpeg mit den configure-Optionen --enable-gpl --enable-libx264. Jetzt lassen Sie uns gehen, um die Codierung. Der relevante Teil des Codes erreicht werden, dass die angeforderten Zweck ist das folgende:

Umfasst:

#include <stdint.h>
extern "C"{
#include <x264.h>
#include <libswscale/swscale.h>
#include <libavcodec/avcodec.h>
#include <libavutil/mathematics.h>
#include <libavformat/avformat.h>
#include <libavutil/opt.h>
}

LDFLAGS auf Makefile:

-lx264 -lswscale -lavutil -lavformat -lavcodec

Inner code (der Einfachheit halber, wird der Fehler checkings wird weggelassen werden, und die Deklarationen von Variablen erfolgt dann, wenn notwendig, anstelle der Anfang zum besseren Verständnis):

av_register_all(); //Loads the whole database of available codecs and formats.

struct SwsContext* convertCtx = sws_getContext(width, height, AV_PIX_FMT_RGB24, width, height, AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL); //Preparing to convert my generated RGB images to YUV frames.

//Preparing the data concerning the format and codec in order to write properly the header, frame data and end of file.
char *fmtext="mp4";
char *filename;
sprintf(filename, "GeneratedVideo.%s", fmtext);
AVOutputFormat * fmt = av_guess_format(fmtext, NULL, NULL);
AVFormatContext *oc = NULL;
avformat_alloc_output_context2(&oc, NULL, NULL, filename);
AVStream * stream = avformat_new_stream(oc, 0);
AVCodec *codec=NULL;
AVCodecContext *c= NULL;
int ret;

codec = avcodec_find_encoder_by_name("libx264");

//Setting up the codec:
av_dict_set( &opt, "preset", "slow", 0 );
av_dict_set( &opt, "crf", "20", 0 );
avcodec_get_context_defaults3(stream->codec, codec);
c=avcodec_alloc_context3(codec);
c->width = width;
c->height = height;
c->pix_fmt = AV_PIX_FMT_YUV420P;

//Setting up the format, its stream(s), linking with the codec(s) and write the header:
if (oc->oformat->flags & AVFMT_GLOBALHEADER) //Some formats require a global header.
    c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
avcodec_open2( c, codec, &opt );
av_dict_free(&opt);
stream->time_base=(AVRational){1, 25};
stream->codec=c; //Once the codec is set up, we need to let the container know which codec are the streams using, in this case the only (video) stream.
av_dump_format(oc, 0, filename, 1);
avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
ret=avformat_write_header(oc, &opt);
av_dict_free(&opt); 

//Preparing the containers of the frame data:
AVFrame *rgbpic, *yuvpic;

//Allocating memory for each RGB frame, which will be lately converted to YUV:
rgbpic=av_frame_alloc();
rgbpic->format=AV_PIX_FMT_RGB24;
rgbpic->width=width;
rgbpic->height=height;
ret=av_frame_get_buffer(rgbpic, 1);

//Allocating memory for each conversion output YUV frame:
yuvpic=av_frame_alloc();
yuvpic->format=AV_PIX_FMT_YUV420P;
yuvpic->width=width;
yuvpic->height=height;
ret=av_frame_get_buffer(yuvpic, 1);

//After the format, code and general frame data is set, we write the video in the frame generation loop:
//std::vector<uint8_t> B(width*height*3);

Den oben kommentiert Vektor hat die gleiche Struktur als die, die ich ausgesetzt in meine Frage; jedoch die RGB-Daten werden auf der AVFrames in einer bestimmten Weise. Daher, im Interesse der Ausstellung, lassen Sie uns annehmen, wir haben statt dessen einen Zeiger auf eine Struktur der form uint8_t[3] Matrix(int, int), dessen Zugriff auf die Farbwerte der Pixel für eine bestimmte Koordinate (x, y) Matrix(x, y)->Rot, Matrix(x, y)->Green und Matrix(x, y)->Blau, um zu bekommen, bzw. auf der roten, grün-und blau-Werte der Koordinate (x, y). Das erste argument steht für die horizontale position, von Links nach rechts als x erhöht und der zweite für die vertikale position, von oben nach unten als y erhöht.

Wesen, das sagte, die für Schleife um die Daten zu übertragen, codieren und schreiben Sie jeden frame, wäre die folgende:

Matrix B(width, height);
int got_output;
AVPacket pkt;
for (i=0; i<N; i++)
{
    generateframe(B, i); //This one is the function that generates a different frame for each i.
    //The AVFrame data will be stored as RGBRGBRGB... row-wise, from left to right and from top to bottom, hence we have to proceed as follows:
    for (y=0; y<height; y++)
    {
        for (x=0; x<width; x++)
        {
            //rgbpic->linesize[0] is equal to width.
            rgbpic->data[0][y*rgbpic->linesize[0]+3*x]=B(x, y)->Red;
            rgbpic->data[0][y*rgbpic->linesize[0]+3*x+1]=B(x, y)->Green;
            rgbpic->data[0][y*rgbpic->linesize[0]+3*x+2]=B(x, y)->Blue;
        }
    }
    sws_scale(convertCtx, rgbpic->data, rgbpic->linesize, 0, height, yuvpic->data, yuvpic->linesize); //Not actually scaling anything, but just converting the RGB data to YUV and store it in yuvpic.
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;
    yuvpic->pts = i; //The PTS of the frame are just in a reference unit, unrelated to the format we are using. We set them, for instance, as the corresponding frame number.
    ret=avcodec_encode_video2(c, &pkt, yuvpic, &got_output);
    if (got_output)
    {
        fflush(stdout);
        av_packet_rescale_ts(&pkt, (AVRational){1, 25}, stream->time_base); //We set the packet PTS and DTS taking in the account our FPS (second argument) and the time base that our selected format uses (third argument).
        pkt.stream_index = stream->index;
        printf("Write frame %6d (size=%6d)\n", i, pkt.size);
        av_interleaved_write_frame(oc, &pkt); //Write the encoded frame to the mp4 file.
        av_packet_unref(&pkt);
    }
}
//Writing the delayed frames:
for (got_output = 1; got_output; i++) {
    ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
    if (got_output) {
        fflush(stdout);
        av_packet_rescale_ts(&pkt, (AVRational){1, 25}, stream->time_base);
        pkt.stream_index = stream->index;
        printf("Write frame %6d (size=%6d)\n", i, pkt.size);
        av_interleaved_write_frame(oc, &pkt);
        av_packet_unref(&pkt);
    }
}
av_write_trailer(oc); //Writing the end of the file.
if (!(fmt->flags & AVFMT_NOFILE))
    avio_closep(oc->pb); //Closing the file.
avcodec_close(stream->codec);
//Freeing all the allocated memory:
sws_freeContext(convertCtx);
av_frame_free(&rgbpic);
av_frame_free(&yuvpic);
avformat_free_context(oc);

Seite Hinweise:

Für zukünftige Referenz, da die verfügbaren Informationen auf dem Netz über den Zeitstempel (PTS/DTS) sieht so verwirrend, werde ich weiter erklären, so gut wie ich Tat, zu verwalten, um die Probleme zu lösen, durch die Einstellung der richtigen Werte. Setzt man diese Werte fälschlicherweise verursacht, dass die Ausgabe-Größe war viel größer als die, die durch die ffmpeg gebaut binäre Kommandozeilen-tool, da die frame-Daten werden Redundant geschrieben durch kleinere Zeitintervalle als die tatsächlich durch die FPS.

Zuerst von all, es sollte angemerkt werden, dass bei der Codierung gibt es zwei Arten von Zeitmarken: ein Zusammenhang zu dem Rahmen (PTS) (pre-encoding-Stufe) und zwei zugeordnet, wird das Paket (PTS und DTS) (nach der Kodierung der Bühne). Im ersten Fall sieht es so aus das frame PTS-Werte zugeordnet werden können, mithilfe einer benutzerdefinierten Einheit der Referenz (mit der einzigen Einschränkung, dass Sie werden müssen, in gleichem Abstand, wenn man will dem Konstanten FPS), so kann man zum Beispiel die Nummer des Bildes, wie wir es im obigen code. In der zweiten, wir haben berücksichtigt die folgenden Parameter:

• Die Zeitbasis des Ausgabe-format-container, in unserem Fall mp4 (=12800 Hz), deren Informationen sich in-stream->time_base.
• Die gewünschte FPS des Videos.
• Wenn der encoder erzeugt B-frames oder nicht (im zweiten Fall die PTS-und DTS-Werte für den Rahmen gesetzt werden muss, die gleiche, aber es ist noch komplizierter, wenn wir im ersten Fall, wie in diesem Beispiel). Sehen Sie diese Antwort zum anderen stellt sich die Frage, für weitere Referenzen.

Der Schlüssel hier ist, zum Glück ist es nicht notwendig, zu kämpfen mit der Berechnung dieser Mengen, als libav enthält eine Funktion zum berechnen der korrekten Zeitstempel zugeordnet, um das Paket durch die Kenntnis der oben genannten Daten:

av_packet_rescale_ts(AVPacket *pkt, AVRational FPS, AVRational time_base)

Danke für diese überlegungen, ich war schließlich in der Lage, erzeugen ein vernünftiger output-container und im wesentlichen die gleiche Kompressionsrate als die, die mit dem commandline-tool, das waren die zwei verbleibenden Fragen vor der Untersuchung noch tiefer, wie das format der header-und trailer-und wie die Zeit, die Stempel sind richtig eingestellt.

Dank ksb496 habe ich es geschafft, das zu tun diese Aufgabe, aber in meinem Fall muss ich einiges ändern-codes wie erwartet arbeiten. Ich dachte, vielleicht könnte es anderen helfen, also habe ich beschlossen, zu teilen (mit zwei Jahren Verzögerung :D).

Hatte ich eine RGB - Puffer gefüllt, die von directshow sample grabber, die ich brauchte, um ein video aus. RGB zu YUV Umwandlung von gegebenen Antwort nicht die Arbeit zu tun für mich. Ich habe es wie folgt aus :

int stride = m_width * 3;
int index = 0;
for (int y = 0; y < m_height; y++) {
    for (int x = 0; x < stride; x++) {
        int j = (size - ((y + 1)*stride)) + x;
        m_rgbpic->data[0][j] = data[index];
        ++index;
    }
}

data variable hier ist mein RGB - Puffer (einfach BYTE*) und size ist data Puffergröße in bytes. Es ist start-Füllung RGB AVFrame von Links unten nach rechts oben.

Die andere Sache ist, dass meine version von FFMPEG nicht av_packet_rescale_ts Funktion. Es ist die Letzte version, aber FFMPEG-docs nicht sagen, diese Funktion ist veraltet und überall, ich denke, dies könnte der Fall sein, nur für windows. Jedenfalls habe ich verwendet av_rescale_q statt, dass macht die gleiche Arbeit. wie diese :

AVPacket pkt;
pkt.pts = av_rescale_q(pkt.pts, { 1, 25 }, m_stream->time_base);

Und die Letzte Sache, mit diesem format-Konvertierung, die ich brauchte, um zu ändern, mein swsContext zu BGR24 statt RGB24 wie diese :

m_convert_ctx = sws_getContext(width, height, AV_PIX_FMT_BGR24, width, height,
        AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);