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

   1 /*
   2  * copyright (c) 2001 Fabrice Bellard
   3  *
   4  * This file is part of Libav.
   5  *
   6  * Libav is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Libav is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with Libav; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /**
  22  * @file
  23  * libavcodec API use example.
  24  *
  25  * @example avcodec.c
  26  * Note that this library only handles codecs (mpeg, mpeg4, etc...),
  27  * not file formats (avi, vob, etc...). See library 'libavformat' for the
  28  * format handling
  29  */
  30
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34
  35 #ifdef HAVE_AV_CONFIG_H
  36 #undef HAVE_AV_CONFIG_H
  37 #endif
  38
  39 #include "libavcodec/avcodec.h"
  40 #include "libavutil/channel_layout.h"
  41 #include "libavutil/common.h"
  42 #include "libavutil/imgutils.h"
  43 #include "libavutil/mathematics.h"
  44 #include "libavutil/samplefmt.h"
  45
  46 #define INBUF_SIZE 4096
  47 #define AUDIO_INBUF_SIZE 20480
  48 #define AUDIO_REFILL_THRESH 4096
  49
  50 /* check that a given sample format is supported by the encoder */
  51 static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
  52 {
  53     const enum AVSampleFormat *p = codec->sample_fmts;
  54
  55     while (*p != AV_SAMPLE_FMT_NONE) {
  56         if (*p == sample_fmt)
  57             return 1;
  58         p++;
  59     }
  60     return 0;
  61 }
  62
  63 /* just pick the highest supported samplerate */
  64 static int select_sample_rate(AVCodec *codec)
  65 {
  66     const int *p;
  67     int best_samplerate = 0;
  68
  69     if (!codec->supported_samplerates)
  70         return 44100;
  71
  72     p = codec->supported_samplerates;
  73     while (*p) {
  74         best_samplerate = FFMAX(*p, best_samplerate);
  75         p++;
  76     }
  77     return best_samplerate;
  78 }
  79
  80 /* select layout with the highest channel count */
  81 static int select_channel_layout(AVCodec *codec)
  82 {
  83     const uint64_t *p;
  84     uint64_t best_ch_layout = 0;
  85     int best_nb_channels   = 0;
  86
  87     if (!codec->channel_layouts)
  88         return AV_CH_LAYOUT_STEREO;
  89
  90     p = codec->channel_layouts;
  91     while (*p) {
  92         int nb_channels = av_get_channel_layout_nb_channels(*p);
  93
  94         if (nb_channels > best_nb_channels) {
  95             best_ch_layout    = *p;
  96             best_nb_channels = nb_channels;
  97         }
  98         p++;
  99     }
 100     return best_ch_layout;
 101 }
 102
 103 /*
 104  * Audio encoding example
 105  */
 106 static void audio_encode_example(const char *filename)
 107 {
 108     AVCodec *codec;
 109     AVCodecContext *c= NULL;
 110     AVFrame *frame;
 111     AVPacket pkt;
 112     int i, j, k, ret, got_output;
 113     int buffer_size;
 114     FILE *f;
 115     uint16_t *samples;
 116     float t, tincr;
 117
 118     printf("Audio encoding\n");
 119
 120     /* find the MP2 encoder */
 121     codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
 122     if (!codec) {
 123         fprintf(stderr, "codec not found\n");
 124         exit(1);
 125     }
 126
 127     c = avcodec_alloc_context3(codec);
 128
 129     /* put sample parameters */
 130     c->bit_rate = 64000;
 131
 132     /* check that the encoder supports s16 pcm input */
 133     c->sample_fmt = AV_SAMPLE_FMT_S16;
 134     if (!check_sample_fmt(codec, c->sample_fmt)) {
 135         fprintf(stderr, "encoder does not support %s",
 136                 av_get_sample_fmt_name(c->sample_fmt));
 137         exit(1);
 138     }
 139
 140     /* select other audio parameters supported by the encoder */
 141     c->sample_rate    = select_sample_rate(codec);
 142     c->channel_layout = select_channel_layout(codec);
 143     c->channels       = av_get_channel_layout_nb_channels(c->channel_layout);
 144
 145     /* open it */
 146     if (avcodec_open2(c, codec, NULL) < 0) {
 147         fprintf(stderr, "could not open codec\n");
 148         exit(1);
 149     }
 150
 151     f = fopen(filename, "wb");
 152     if (!f) {
 153         fprintf(stderr, "could not open %s\n", filename);
 154         exit(1);
 155     }
 156
 157     /* frame containing input raw audio */
 158     frame = av_frame_alloc();
 159     if (!frame) {
 160         fprintf(stderr, "could not allocate audio frame\n");
 161         exit(1);
 162     }
 163
 164     frame->nb_samples     = c->frame_size;
 165     frame->format         = c->sample_fmt;
 166     frame->channel_layout = c->channel_layout;
 167
 168     /* the codec gives us the frame size, in samples,
 169      * we calculate the size of the samples buffer in bytes */
 170     buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
 171                                              c->sample_fmt, 0);
 172     samples = av_malloc(buffer_size);
 173     if (!samples) {
 174         fprintf(stderr, "could not allocate %d bytes for samples buffer\n",
 175                 buffer_size);
 176         exit(1);
 177     }
 178     /* setup the data pointers in the AVFrame */
 179     ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
 180                                    (const uint8_t*)samples, buffer_size, 0);
 181     if (ret < 0) {
 182         fprintf(stderr, "could not setup audio frame\n");
 183         exit(1);
 184     }
 185
 186     /* encode a single tone sound */
 187     t = 0;
 188     tincr = 2 * M_PI * 440.0 / c->sample_rate;
 189     for(i=0;i<200;i++) {
 190         av_init_packet(&pkt);
 191         pkt.data = NULL; // packet data will be allocated by the encoder
 192         pkt.size = 0;
 193
 194         for (j = 0; j < c->frame_size; j++) {
 195             samples[2*j] = (int)(sin(t) * 10000);
 196
 197             for (k = 1; k < c->channels; k++)
 198                 samples[2*j + k] = samples[2*j];
 199             t += tincr;
 200         }
 201         /* encode the samples */
 202         ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
 203         if (ret < 0) {
 204             fprintf(stderr, "error encoding audio frame\n");
 205             exit(1);
 206         }
 207         if (got_output) {
 208             fwrite(pkt.data, 1, pkt.size, f);
 209             av_packet_unref(&pkt);
 210         }
 211     }
 212     fclose(f);
 213
 214     av_freep(&samples);
 215     av_frame_free(&frame);
 216     avcodec_close(c);
 217     av_free(c);
 218 }
 219
 220 /*
 221  * Audio decoding.
 222  */
 223 static void audio_decode_example(const char *outfilename, const char *filename)
 224 {
 225     AVCodec *codec;
 226     AVCodecContext *c= NULL;
 227     int len;
 228     FILE *f, *outfile;
 229     uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
 230     AVPacket avpkt;
 231     AVFrame *decoded_frame = NULL;
 232
 233     av_init_packet(&avpkt);
 234
 235     printf("Audio decoding\n");
 236
 237     /* find the mpeg audio decoder */
 238     codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
 239     if (!codec) {
 240         fprintf(stderr, "codec not found\n");
 241         exit(1);
 242     }
 243
 244     c = avcodec_alloc_context3(codec);
 245
 246     /* open it */
 247     if (avcodec_open2(c, codec, NULL) < 0) {
 248         fprintf(stderr, "could not open codec\n");
 249         exit(1);
 250     }
 251
 252     f = fopen(filename, "rb");
 253     if (!f) {
 254         fprintf(stderr, "could not open %s\n", filename);
 255         exit(1);
 256     }
 257     outfile = fopen(outfilename, "wb");
 258     if (!outfile) {
 259         av_free(c);
 260         exit(1);
 261     }
 262
 263     /* decode until eof */
 264     avpkt.data = inbuf;
 265     avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
 266
 267     while (avpkt.size > 0) {
 268         int got_frame = 0;
 269
 270         if (!decoded_frame) {
 271             if (!(decoded_frame = av_frame_alloc())) {
 272                 fprintf(stderr, "out of memory\n");
 273                 exit(1);
 274             }
 275         }
 276
 277         len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
 278         if (len < 0) {
 279             fprintf(stderr, "Error while decoding\n");
 280             exit(1);
 281         }
 282         if (got_frame) {
 283             /* if a frame has been decoded, output it */
 284             int data_size = av_samples_get_buffer_size(NULL, c->channels,
 285                                                        decoded_frame->nb_samples,
 286                                                        c->sample_fmt, 1);
 287             fwrite(decoded_frame->data[0], 1, data_size, outfile);
 288         }
 289         avpkt.size -= len;
 290         avpkt.data += len;
 291         if (avpkt.size < AUDIO_REFILL_THRESH) {
 292             /* Refill the input buffer, to avoid trying to decode
 293              * incomplete frames. Instead of this, one could also use
 294              * a parser, or use a proper container format through
 295              * libavformat. */
 296             memmove(inbuf, avpkt.data, avpkt.size);
 297             avpkt.data = inbuf;
 298             len = fread(avpkt.data + avpkt.size, 1,
 299                         AUDIO_INBUF_SIZE - avpkt.size, f);
 300             if (len > 0)
 301                 avpkt.size += len;
 302         }
 303     }
 304
 305     fclose(outfile);
 306     fclose(f);
 307
 308     avcodec_close(c);
 309     av_free(c);
 310     av_frame_free(&decoded_frame);
 311 }
 312
 313 /*
 314  * Video encoding example
 315  */
 316 static void video_encode_example(const char *filename)
 317 {
 318     AVCodec *codec;
 319     AVCodecContext *c= NULL;
 320     int i, ret, x, y, got_output;
 321     FILE *f;
 322     AVFrame *picture;
 323     AVPacket pkt;
 324     uint8_t endcode[] = { 0, 0, 1, 0xb7 };
 325
 326     printf("Video encoding\n");
 327
 328     /* find the mpeg1 video encoder */
 329     codec = avcodec_find_encoder(AV_CODEC_ID_MPEG1VIDEO);
 330     if (!codec) {
 331         fprintf(stderr, "codec not found\n");
 332         exit(1);
 333     }
 334
 335     c = avcodec_alloc_context3(codec);
 336     picture = av_frame_alloc();
 337
 338     /* put sample parameters */
 339     c->bit_rate = 400000;
 340     /* resolution must be a multiple of two */
 341     c->width = 352;
 342     c->height = 288;
 343     /* frames per second */
 344     c->time_base= (AVRational){1,25};
 345     c->gop_size = 10; /* emit one intra frame every ten frames */
 346     c->max_b_frames=1;
 347     c->pix_fmt = AV_PIX_FMT_YUV420P;
 348
 349     /* open it */
 350     if (avcodec_open2(c, codec, NULL) < 0) {
 351         fprintf(stderr, "could not open codec\n");
 352         exit(1);
 353     }
 354
 355     f = fopen(filename, "wb");
 356     if (!f) {
 357         fprintf(stderr, "could not open %s\n", filename);
 358         exit(1);
 359     }
 360
 361     ret = av_image_alloc(picture->data, picture->linesize, c->width, c->height,
 362                          c->pix_fmt, 32);
 363     if (ret < 0) {
 364         fprintf(stderr, "could not alloc raw picture buffer\n");
 365         exit(1);
 366     }
 367     picture->format = c->pix_fmt;
 368     picture->width  = c->width;
 369     picture->height = c->height;
 370
 371     /* encode 1 second of video */
 372     for(i=0;i<25;i++) {
 373         av_init_packet(&pkt);
 374         pkt.data = NULL;    // packet data will be allocated by the encoder
 375         pkt.size = 0;
 376
 377         fflush(stdout);
 378         /* prepare a dummy image */
 379         /* Y */
 380         for(y=0;y<c->height;y++) {
 381             for(x=0;x<c->width;x++) {
 382                 picture->data[0][y * picture->linesize[0] + x] = x + y + i * 3;
 383             }
 384         }
 385
 386         /* Cb and Cr */
 387         for(y=0;y<c->height/2;y++) {
 388             for(x=0;x<c->width/2;x++) {
 389                 picture->data[1][y * picture->linesize[1] + x] = 128 + y + i * 2;
 390                 picture->data[2][y * picture->linesize[2] + x] = 64 + x + i * 5;
 391             }
 392         }
 393
 394         picture->pts = i;
 395
 396         /* encode the image */
 397         ret = avcodec_encode_video2(c, &pkt, picture, &got_output);
 398         if (ret < 0) {
 399             fprintf(stderr, "error encoding frame\n");
 400             exit(1);
 401         }
 402
 403         if (got_output) {
 404             printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
 405             fwrite(pkt.data, 1, pkt.size, f);
 406             av_packet_unref(&pkt);
 407         }
 408     }
 409
 410     /* get the delayed frames */
 411     for (got_output = 1; got_output; i++) {
 412         fflush(stdout);
 413
 414         ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
 415         if (ret < 0) {
 416             fprintf(stderr, "error encoding frame\n");
 417             exit(1);
 418         }
 419
 420         if (got_output) {
 421             printf("encoding frame %3d (size=%5d)\n", i, pkt.size);
 422             fwrite(pkt.data, 1, pkt.size, f);
 423             av_packet_unref(&pkt);
 424         }
 425     }
 426
 427     /* add sequence end code to have a real mpeg file */
 428     fwrite(endcode, 1, sizeof(endcode), f);
 429     fclose(f);
 430
 431     avcodec_close(c);
 432     av_free(c);
 433     av_freep(&picture->data[0]);
 434     av_frame_free(&picture);
 435     printf("\n");
 436 }
 437
 438 /*
 439  * Video decoding example
 440  */
 441
 442 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
 443                      char *filename)
 444 {
 445     FILE *f;
 446     int i;
 447
 448     f=fopen(filename,"w");
 449     fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
 450     for(i=0;i<ysize;i++)
 451         fwrite(buf + i * wrap,1,xsize,f);
 452     fclose(f);
 453 }
 454
 455 static void video_decode_example(const char *outfilename, const char *filename)
 456 {
 457     AVCodec *codec;
 458     AVCodecContext *c= NULL;
 459     int frame, got_picture, len;
 460     FILE *f;
 461     AVFrame *picture;
 462     uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
 463     char buf[1024];
 464     AVPacket avpkt;
 465
 466     av_init_packet(&avpkt);
 467
 468     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
 469     memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 470
 471     printf("Video decoding\n");
 472
 473     /* find the mpeg1 video decoder */
 474     codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
 475     if (!codec) {
 476         fprintf(stderr, "codec not found\n");
 477         exit(1);
 478     }
 479
 480     c = avcodec_alloc_context3(codec);
 481     picture = av_frame_alloc();
 482
 483     if (codec->capabilities & AV_CODEC_CAP_TRUNCATED)
 484         c->flags |= AV_CODEC_FLAG_TRUNCATED; // we do not send complete frames
 485
 486     /* For some codecs, such as msmpeg4 and mpeg4, width and height
 487        MUST be initialized there because this information is not
 488        available in the bitstream. */
 489
 490     /* open it */
 491     if (avcodec_open2(c, codec, NULL) < 0) {
 492         fprintf(stderr, "could not open codec\n");
 493         exit(1);
 494     }
 495
 496     /* the codec gives us the frame size, in samples */
 497
 498     f = fopen(filename, "rb");
 499     if (!f) {
 500         fprintf(stderr, "could not open %s\n", filename);
 501         exit(1);
 502     }
 503
 504     frame = 0;
 505     for(;;) {
 506         avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
 507         if (avpkt.size == 0)
 508             break;
 509
 510         /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
 511            and this is the only method to use them because you cannot
 512            know the compressed data size before analysing it.
 513
 514            BUT some other codecs (msmpeg4, mpeg4) are inherently frame
 515            based, so you must call them with all the data for one
 516            frame exactly. You must also initialize 'width' and
 517            'height' before initializing them. */
 518
 519         /* NOTE2: some codecs allow the raw parameters (frame size,
 520            sample rate) to be changed at any frame. We handle this, so
 521            you should also take care of it */
 522
 523         /* here, we use a stream based decoder (mpeg1video), so we
 524            feed decoder and see if it could decode a frame */
 525         avpkt.data = inbuf;
 526         while (avpkt.size > 0) {
 527             len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
 528             if (len < 0) {
 529                 fprintf(stderr, "Error while decoding frame %d\n", frame);
 530                 exit(1);
 531             }
 532             if (got_picture) {
 533                 printf("saving frame %3d\n", frame);
 534                 fflush(stdout);
 535
 536                 /* the picture is allocated by the decoder. no need to
 537                    free it */
 538                 snprintf(buf, sizeof(buf), outfilename, frame);
 539                 pgm_save(picture->data[0], picture->linesize[0],
 540                          c->width, c->height, buf);
 541                 frame++;
 542             }
 543             avpkt.size -= len;
 544             avpkt.data += len;
 545         }
 546     }
 547
 548     /* some codecs, such as MPEG, transmit the I and P frame with a
 549        latency of one frame. You must do the following to have a
 550        chance to get the last frame of the video */
 551     avpkt.data = NULL;
 552     avpkt.size = 0;
 553     len = avcodec_decode_video2(c, picture, &got_picture, &avpkt);
 554     if (got_picture) {
 555         printf("saving last frame %3d\n", frame);
 556         fflush(stdout);
 557
 558         /* the picture is allocated by the decoder. no need to
 559            free it */
 560         snprintf(buf, sizeof(buf), outfilename, frame);
 561         pgm_save(picture->data[0], picture->linesize[0],
 562                  c->width, c->height, buf);
 563         frame++;
 564     }
 565
 566     fclose(f);
 567
 568     avcodec_close(c);
 569     av_free(c);
 570     av_frame_free(&picture);
 571     printf("\n");
 572 }
 573
 574 int main(int argc, char **argv)
 575 {
 576     const char *filename;
 577
 578     /* register all the codecs */
 579     avcodec_register_all();
 580
 581     if (argc <= 1) {
 582         audio_encode_example("/tmp/test.mp2");
 583         audio_decode_example("/tmp/test.sw", "/tmp/test.mp2");
 584
 585         video_encode_example("/tmp/test.mpg");
 586         filename = "/tmp/test.mpg";
 587     } else {
 588         filename = argv[1];
 589     }
 590
 591     //    audio_decode_example("/tmp/test.sw", filename);
 592     video_decode_example("/tmp/test%d.pgm", filename);
 593
 594     return 0;
 595 }