So verwenden Sie die Hardwarebeschleunigung mit ffmpeg

Ich muss mein Video (z. B. h264) mit Hardwarebeschleunigung von ffmpeg decodieren lassen. Ich verwende die übliche Methode zum Decodieren von Frames: Paket lesen -> Frame decodieren. Und ich möchte, dass ffmpeg die Dekodierung beschleunigt. Also ich habe es mit gebaut --enable-vaapi und --enable-hwaccel=h264. Aber ich weiß wirklich nicht, was ich als nächstes tun soll. Ich habe versucht zu verwenden avcodec_find_decoder_by_name("h264_vaapi") aber es gibt nullptr zurück. Wie auch immer, ich möchte vielleicht eine andere API verwenden und nicht nur die VA-API. Wie soll man die ffmpeg-Decodierung beschleunigen?

PS Ich habe im Internet keine Beispiele gefunden, die ffmpeg mit hwaccel verwenden.

Nach einigen Recherchen konnte ich die notwendige HW-beschleunigte Dekodierung auf OS X (VDA) und Linux (VDPAU) implementieren. Ich werde die Antwort aktualisieren, wenn ich auch die Windows-Implementierung in die Hände bekomme. Beginnen wir also mit dem Einfachsten:

Mac OS X

Um die HW-Beschleunigung unter Mac OS zum Laufen zu bringen, sollten Sie einfach Folgendes verwenden:
avcodec_find_decoder_by_name("h264_vda");
Beachten Sie jedoch, dass Sie h264-Videos nur unter Mac OS mit FFmpeg beschleunigen können.

Linux-VDPAU

Unter Linux sind die Dinge viel komplizierter (wen wundert das?). FFmpeg hat 2 HW-Beschleuniger unter Linux: VDPAU (Nvidia) und VAAPI (Intel) und nur einen HW-Decoder: für VDPAU. Und es mag vollkommen vernünftig erscheinen, den vdpau-Decoder wie im obigen Mac OS-Beispiel zu verwenden:
avcodec_find_decoder_by_name("h264_vdpau");

Sie werden vielleicht überrascht sein herauszufinden, dass es nichts ändert und Sie überhaupt keine Beschleunigung haben. Das liegt daran, dass dies nur der Anfang ist. Sie müssen viel mehr Code schreiben, damit die Beschleunigung funktioniert. Glücklicherweise müssen Sie nicht alleine auf eine Lösung kommen: Es gibt mindestens 2 gute Beispiele dafür, wie Sie das erreichen können: libavg und FFmpeg selbst. libavg hat eine VDPAUDecoder-Klasse, die vollkommen klar ist und auf der ich meine Implementierung basiert habe. Sie können sich auch beraten lassen ffmpeg_vdpau.c um eine andere Implementierung zum Vergleich zu erhalten. Meiner Meinung nach ist die libavg-Implementierung jedoch einfacher zu verstehen.

Das einzige, was beiden oben genannten Beispielen fehlt, ist das richtige Kopieren des decodierten Rahmens in den Hauptspeicher. Beide Beispiele verwendet VdpVideoSurfaceGetBitsYCbCr was die gesamte Leistung, die ich auf meiner Maschine gewonnen habe, zerstört hat. Aus diesem Grund möchten Sie möglicherweise das folgende Verfahren verwenden, um die Daten von einer GPU zu extrahieren:

bool VdpauDecoder::fillFrameWithData(AVCodecContext* context,
    AVFrame* frame)
{
    VdpauDecoder* vdpauDecoder = static_cast<VdpauDecoder*>(context->opaque);
    VdpOutputSurface surface;
    vdp_output_surface_create(m_VdpDevice, VDP_RGBA_FORMAT_B8G8R8A8, frame->width, frame->height, &surface);
    auto renderState = reinterpret_cast<vdpau_render_state*>(frame->data[0]);
    VdpVideoSurface videoSurface = renderState->surface;

    auto status = vdp_video_mixer_render(vdpauDecoder->m_VdpMixer,
        VDP_INVALID_HANDLE,
        nullptr,
        VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME,
        0, nullptr,
        videoSurface,
        0, nullptr,
        nullptr,
        surface,
        nullptr, nullptr, 0, nullptr);
    if(status == VDP_STATUS_OK)
    {
        auto tmframe = av_frame_alloc();
        tmframe->format = AV_PIX_FMT_BGRA;
        tmframe->width = frame->width;
        tmframe->height = frame->height;
        if(av_frame_get_buffer(tmframe, 32) >= 0)
        {
            VdpStatus status = vdp_output_surface_get_bits_native(surface, nullptr,
                reinterpret_cast<void * const *>(tmframe->data),
                reinterpret_cast<const uint32_t *>(tmframe->linesize));
            if(status == VDP_STATUS_OK && av_frame_copy_props(tmframe, frame) == 0)
            {
                av_frame_unref(frame);
                av_frame_move_ref(frame, tmframe);
                return;
            }
        }
        av_frame_unref(tmframe);
    }
    vdp_output_surface_destroy(surface);
    return 0;
}

Obwohl einige “externe” Objekte im Inneren verwendet werden, sollten Sie in der Lage sein, es zu verstehen, sobald Sie den Teil “Puffer abrufen” implementiert haben (für den die oben genannten Beispiele eine große Hilfe sind). Auch ich habe verwendet BGRA Format, das für meine Bedürfnisse besser geeignet war, vielleicht wählen Sie ein anderes.

Das Problem bei all dem ist, dass Sie es nicht einfach von FFmpeg aus zum Laufen bringen können, Sie müssen zumindest die Grundlagen der VDPAU-API verstehen. Und ich hoffe, dass meine Antwort jemandem bei der Implementierung der HW-Beschleunigung unter Linux hilft. Ich habe selbst viel Zeit damit verbracht, bevor mir klar wurde, dass es keinen einfachen, einzeiligen Weg gibt, HW-beschleunigte Dekodierung unter Linux zu implementieren.

Linux-VA-API

Da meine ursprüngliche Frage bezüglich VA-API war, kann ich sie nicht unbeantwortet lassen. Zunächst einmal gibt es in FFmpeg also keinen Decoder für VA-API avcodec_find_decoder_by_name("h264_vaapi") macht keinen Sinn: es ist nullptr. Ich weiß nicht, wie viel schwieriger (oder vielleicht einfacher?) es ist, die Dekodierung über die VA-API zu implementieren, da alle Beispiele, die ich gesehen habe, ziemlich einschüchternd waren. Also habe ich mich dafür entschieden, VA-API überhaupt nicht zu verwenden, und ich musste die Beschleunigung für eine Intel-Karte implementieren. Zum Glück gibt es für mich eine VDPAU-Bibliothek (Treiber?), die über VA-API funktioniert. Sie können also VDPAU auf Intel-Karten verwenden!

Ich habe folgendes verwendet Verknüpfung um es auf meinem Ubuntu einzurichten.

Vielleicht möchten Sie auch die Kommentare zur ursprünglichen Frage überprüfen, in denen @Timothy_G auch einige Links zur VA-API erwähnt hat.