tools/decode_simple.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 /* shared code for simple demux/decode tools */
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include "decode_simple.h"
  25
  26 #include "libavformat/avformat.h"
  27
  28 #include "libavcodec/avcodec.h"
  29 #include "libavcodec/packet.h"
  30
  31 #include "libavutil/dict.h"
  32 #include "libavutil/error.h"
  33 #include "libavutil/frame.h"
  34
  35 static int decode_read(DecodeContext *dc, int flush)
  36 {
  37     const int ret_done = flush ? AVERROR_EOF : AVERROR(EAGAIN);
  38     int ret = 0;
  39
  40     while (ret >= 0 &&
  41            (dc->max_frames == 0 || dc->decoder->frame_num < dc->max_frames)) {
  42         ret = avcodec_receive_frame(dc->decoder, dc->frame);
  43         if (ret < 0) {
  44             if (ret == AVERROR_EOF) {
  45                 int err = dc->process_frame(dc, NULL);
  46                 if (err < 0)
  47                     return err;
  48             }
  49
  50             return (ret == ret_done) ? 0 : ret;
  51         }
  52
  53         ret = dc->process_frame(dc, dc->frame);
  54         av_frame_unref(dc->frame);
  55         if (ret < 0)
  56             return ret;
  57
  58         if (dc->max_frames && dc->decoder->frame_num == dc->max_frames)
  59             return 1;
  60     }
  61
  62     return (dc->max_frames == 0 || dc->decoder->frame_num < dc->max_frames) ? 0 : 1;
  63 }
  64
  65 int ds_run(DecodeContext *dc)
  66 {
  67     int ret;
  68
  69     ret = avcodec_open2(dc->decoder, NULL, &dc->decoder_opts);
  70     if (ret < 0)
  71         return ret;
  72
  73     while (ret >= 0) {
  74         ret = av_read_frame(dc->demuxer, dc->pkt);
  75         if (ret < 0)
  76             break;
  77         if (dc->pkt->stream_index != dc->stream->index) {
  78             av_packet_unref(dc->pkt);
  79             continue;
  80         }
  81
  82         ret = avcodec_send_packet(dc->decoder, dc->pkt);
  83         if (ret < 0) {
  84             fprintf(stderr, "Error decoding: %d\n", ret);
  85             return ret;
  86         }
  87         av_packet_unref(dc->pkt);
  88
  89         ret = decode_read(dc, 0);
  90         if (ret < 0) {
  91             fprintf(stderr, "Error decoding: %d\n", ret);
  92             return ret;
  93         } else if (ret > 0)
  94             goto finish;
  95     }
  96
  97     ret = avcodec_send_packet(dc->decoder, NULL);
  98     if (ret >= 0)
  99         ret = decode_read(dc, 1);
 100     if (ret < 0) {
 101         fprintf(stderr, "Error flushing: %d\n", ret);
 102         return ret;
 103     }
 104
 105 finish:
 106     return dc->process_frame(dc, NULL);
 107 }
 108
 109 void ds_free(DecodeContext *dc)
 110 {
 111     av_dict_free(&dc->decoder_opts);
 112
 113     av_frame_free(&dc->frame);
 114     av_packet_free(&dc->pkt);
 115
 116     avcodec_free_context(&dc->decoder);
 117     avformat_close_input(&dc->demuxer);
 118 }
 119
 120 int ds_open(DecodeContext *dc, const char *url, int stream_idx)
 121 {
 122     const AVCodec *codec;
 123     int ret;
 124
 125     memset(dc, 0, sizeof(*dc));
 126
 127     dc->pkt   = av_packet_alloc();
 128     dc->frame = av_frame_alloc();
 129     if (!dc->pkt || !dc->frame) {
 130         ret = AVERROR(ENOMEM);
 131         goto fail;
 132     }
 133
 134     ret = avformat_open_input(&dc->demuxer, url, NULL, NULL);
 135     if (ret < 0) {
 136         fprintf(stderr, "Error opening input file: %d\n", ret);
 137         return ret;
 138     }
 139
 140     if (stream_idx < 0 || stream_idx >= dc->demuxer->nb_streams)
 141         return AVERROR(EINVAL);
 142
 143     dc->stream = dc->demuxer->streams[stream_idx];
 144
 145     codec = avcodec_find_decoder(dc->stream->codecpar->codec_id);
 146     if (!codec)
 147         return AVERROR_DECODER_NOT_FOUND;
 148
 149     dc->decoder = avcodec_alloc_context3(codec);
 150     if (!dc->decoder)
 151         return AVERROR(ENOMEM);
 152
 153     ret = avcodec_parameters_to_context(dc->decoder, dc->stream->codecpar);
 154     if (ret < 0)
 155         goto fail;
 156
 157     return 0;
 158
 159 fail:
 160     ds_free(dc);
 161     return ret;
 162 }