git.sesse.net Git - ffmpeg/blob - doc/examples/vaapi_transcode.c

   1 /*
   2  * Video Acceleration API (video transcoding) transcode sample
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  */
  22
  23 /**
  24  * @file
  25  * Intel VAAPI-accelerated transcoding example.
  26  *
  27  * @example vaapi_transcode.c
  28  * This example shows how to do VAAPI-accelerated transcoding.
  29  * Usage: vaapi_transcode input_stream codec output_stream
  30  * e.g: - vaapi_transcode input.mp4 h264_vaapi output_h264.mp4
  31  *      - vaapi_transcode input.mp4 vp9_vaapi output_vp9.ivf
  32  */
  33
  34 #include <stdio.h>
  35 #include <errno.h>
  36
  37 #include <libavutil/hwcontext.h>
  38 #include <libavcodec/avcodec.h>
  39 #include <libavformat/avformat.h>
  40
  41 static AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
  42 static AVBufferRef *hw_device_ctx = NULL;
  43 static AVCodecContext *decoder_ctx = NULL, *encoder_ctx = NULL;
  44 static int video_stream = -1;
  45 static AVStream *ost;
  46 static int initialized = 0;
  47
  48 static enum AVPixelFormat get_vaapi_format(AVCodecContext *ctx,
  49                                            const enum AVPixelFormat *pix_fmts)
  50 {
  51     const enum AVPixelFormat *p;
  52
  53     for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
  54         if (*p == AV_PIX_FMT_VAAPI)
  55             return *p;
  56     }
  57
  58     fprintf(stderr, "Unable to decode this file using VA-API.\n");
  59     return AV_PIX_FMT_NONE;
  60 }
  61
  62 static int open_input_file(const char *filename)
  63 {
  64     int ret;
  65     const AVCodec *decoder = NULL;
  66     AVStream *video = NULL;
  67
  68     if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
  69         fprintf(stderr, "Cannot open input file '%s', Error code: %s\n",
  70                 filename, av_err2str(ret));
  71         return ret;
  72     }
  73
  74     if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
  75         fprintf(stderr, "Cannot find input stream information. Error code: %s\n",
  76                 av_err2str(ret));
  77         return ret;
  78     }
  79
  80     ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
  81     if (ret < 0) {
  82         fprintf(stderr, "Cannot find a video stream in the input file. "
  83                 "Error code: %s\n", av_err2str(ret));
  84         return ret;
  85     }
  86     video_stream = ret;
  87
  88     if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
  89         return AVERROR(ENOMEM);
  90
  91     video = ifmt_ctx->streams[video_stream];
  92     if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {
  93         fprintf(stderr, "avcodec_parameters_to_context error. Error code: %s\n",
  94                 av_err2str(ret));
  95         return ret;
  96     }
  97
  98     decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
  99     if (!decoder_ctx->hw_device_ctx) {
 100         fprintf(stderr, "A hardware device reference create failed.\n");
 101         return AVERROR(ENOMEM);
 102     }
 103     decoder_ctx->get_format    = get_vaapi_format;
 104
 105     if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
 106         fprintf(stderr, "Failed to open codec for decoding. Error code: %s\n",
 107                 av_err2str(ret));
 108
 109     return ret;
 110 }
 111
 112 static int encode_write(AVPacket *enc_pkt, AVFrame *frame)
 113 {
 114     int ret = 0;
 115
 116     av_packet_unref(enc_pkt);
 117
 118     if ((ret = avcodec_send_frame(encoder_ctx, frame)) < 0) {
 119         fprintf(stderr, "Error during encoding. Error code: %s\n", av_err2str(ret));
 120         goto end;
 121     }
 122     while (1) {
 123         ret = avcodec_receive_packet(encoder_ctx, enc_pkt);
 124         if (ret)
 125             break;
 126
 127         enc_pkt->stream_index = 0;
 128         av_packet_rescale_ts(enc_pkt, ifmt_ctx->streams[video_stream]->time_base,
 129                              ofmt_ctx->streams[0]->time_base);
 130         ret = av_interleaved_write_frame(ofmt_ctx, enc_pkt);
 131         if (ret < 0) {
 132             fprintf(stderr, "Error during writing data to output file. "
 133                     "Error code: %s\n", av_err2str(ret));
 134             return -1;
 135         }
 136     }
 137
 138 end:
 139     if (ret == AVERROR_EOF)
 140         return 0;
 141     ret = ((ret == AVERROR(EAGAIN)) ? 0:-1);
 142     return ret;
 143 }
 144
 145 static int dec_enc(AVPacket *pkt, const AVCodec *enc_codec)
 146 {
 147     AVFrame *frame;
 148     int ret = 0;
 149
 150     ret = avcodec_send_packet(decoder_ctx, pkt);
 151     if (ret < 0) {
 152         fprintf(stderr, "Error during decoding. Error code: %s\n", av_err2str(ret));
 153         return ret;
 154     }
 155
 156     while (ret >= 0) {
 157         if (!(frame = av_frame_alloc()))
 158             return AVERROR(ENOMEM);
 159
 160         ret = avcodec_receive_frame(decoder_ctx, frame);
 161         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 162             av_frame_free(&frame);
 163             return 0;
 164         } else if (ret < 0) {
 165             fprintf(stderr, "Error while decoding. Error code: %s\n", av_err2str(ret));
 166             goto fail;
 167         }
 168
 169         if (!initialized) {
 170             /* we need to ref hw_frames_ctx of decoder to initialize encoder's codec.
 171                Only after we get a decoded frame, can we obtain its hw_frames_ctx */
 172             encoder_ctx->hw_frames_ctx = av_buffer_ref(decoder_ctx->hw_frames_ctx);
 173             if (!encoder_ctx->hw_frames_ctx) {
 174                 ret = AVERROR(ENOMEM);
 175                 goto fail;
 176             }
 177             /* set AVCodecContext Parameters for encoder, here we keep them stay
 178              * the same as decoder.
 179              * xxx: now the sample can't handle resolution change case.
 180              */
 181             encoder_ctx->time_base = av_inv_q(decoder_ctx->framerate);
 182             encoder_ctx->pix_fmt   = AV_PIX_FMT_VAAPI;
 183             encoder_ctx->width     = decoder_ctx->width;
 184             encoder_ctx->height    = decoder_ctx->height;
 185
 186             if ((ret = avcodec_open2(encoder_ctx, enc_codec, NULL)) < 0) {
 187                 fprintf(stderr, "Failed to open encode codec. Error code: %s\n",
 188                         av_err2str(ret));
 189                 goto fail;
 190             }
 191
 192             if (!(ost = avformat_new_stream(ofmt_ctx, enc_codec))) {
 193                 fprintf(stderr, "Failed to allocate stream for output format.\n");
 194                 ret = AVERROR(ENOMEM);
 195                 goto fail;
 196             }
 197
 198             ost->time_base = encoder_ctx->time_base;
 199             ret = avcodec_parameters_from_context(ost->codecpar, encoder_ctx);
 200             if (ret < 0) {
 201                 fprintf(stderr, "Failed to copy the stream parameters. "
 202                         "Error code: %s\n", av_err2str(ret));
 203                 goto fail;
 204             }
 205
 206             /* write the stream header */
 207             if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) {
 208                 fprintf(stderr, "Error while writing stream header. "
 209                         "Error code: %s\n", av_err2str(ret));
 210                 goto fail;
 211             }
 212
 213             initialized = 1;
 214         }
 215
 216         if ((ret = encode_write(pkt, frame)) < 0)
 217             fprintf(stderr, "Error during encoding and writing.\n");
 218
 219 fail:
 220         av_frame_free(&frame);
 221         if (ret < 0)
 222             return ret;
 223     }
 224     return 0;
 225 }
 226
 227 int main(int argc, char **argv)
 228 {
 229     const AVCodec *enc_codec;
 230     int ret = 0;
 231     AVPacket *dec_pkt;
 232
 233     if (argc != 4) {
 234         fprintf(stderr, "Usage: %s <input file> <encode codec> <output file>\n"
 235                 "The output format is guessed according to the file extension.\n"
 236                 "\n", argv[0]);
 237         return -1;
 238     }
 239
 240     ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, NULL, NULL, 0);
 241     if (ret < 0) {
 242         fprintf(stderr, "Failed to create a VAAPI device. Error code: %s\n", av_err2str(ret));
 243         return -1;
 244     }
 245
 246     dec_pkt = av_packet_alloc();
 247     if (!dec_pkt) {
 248         fprintf(stderr, "Failed to allocate decode packet\n");
 249         goto end;
 250     }
 251
 252     if ((ret = open_input_file(argv[1])) < 0)
 253         goto end;
 254
 255     if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
 256         fprintf(stderr, "Could not find encoder '%s'\n", argv[2]);
 257         ret = -1;
 258         goto end;
 259     }
 260
 261     if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
 262         fprintf(stderr, "Failed to deduce output format from file extension. Error code: "
 263                 "%s\n", av_err2str(ret));
 264         goto end;
 265     }
 266
 267     if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
 268         ret = AVERROR(ENOMEM);
 269         goto end;
 270     }
 271
 272     ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
 273     if (ret < 0) {
 274         fprintf(stderr, "Cannot open output file. "
 275                 "Error code: %s\n", av_err2str(ret));
 276         goto end;
 277     }
 278
 279     /* read all packets and only transcoding video */
 280     while (ret >= 0) {
 281         if ((ret = av_read_frame(ifmt_ctx, dec_pkt)) < 0)
 282             break;
 283
 284         if (video_stream == dec_pkt->stream_index)
 285             ret = dec_enc(dec_pkt, enc_codec);
 286
 287         av_packet_unref(dec_pkt);
 288     }
 289
 290     /* flush decoder */
 291     av_packet_unref(dec_pkt);
 292     ret = dec_enc(dec_pkt, enc_codec);
 293
 294     /* flush encoder */
 295     ret = encode_write(dec_pkt, NULL);
 296
 297     /* write the trailer for output stream */
 298     av_write_trailer(ofmt_ctx);
 299
 300 end:
 301     avformat_close_input(&ifmt_ctx);
 302     avformat_close_input(&ofmt_ctx);
 303     avcodec_free_context(&decoder_ctx);
 304     avcodec_free_context(&encoder_ctx);
 305     av_buffer_unref(&hw_device_ctx);
 306     av_packet_free(&dec_pkt);
 307     return ret;
 308 }