b51c7668781cf358057dbe31181ffa2572eab73d
[ffmpeg.git] / tools / target_dem_fuzzer.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 #include "config.h"
20 #include "libavutil/avassert.h"
21
22 #include "libavcodec/avcodec.h"
23 #include "libavcodec/bytestream.h"
24 #include "libavformat/avformat.h"
25
26
27 typedef struct IOContext {
28     int64_t pos;
29     int64_t filesize;
30     uint8_t *fuzz;
31     int fuzz_size;
32 } IOContext;
33
34 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
35
36 static void error(const char *err)
37 {
38     fprintf(stderr, "%s", err);
39     exit(1);
40 }
41
42 static int io_read(void *opaque, uint8_t *buf, int buf_size)
43 {
44     IOContext *c = opaque;
45     int size = FFMIN(buf_size, c->fuzz_size);
46
47     if (!c->fuzz_size) {
48         c->filesize = FFMIN(c->pos, c->filesize);
49         return AVERROR_EOF;
50     }
51
52     memcpy(buf, c->fuzz, size);
53     c->fuzz      += size;
54     c->fuzz_size -= size;
55     c->pos       += size;
56     c->filesize   = FFMAX(c->filesize, c->pos);
57
58     return size;
59 }
60
61 static int64_t io_seek(void *opaque, int64_t offset, int whence)
62 {
63     IOContext *c = opaque;
64
65     if (whence == SEEK_CUR) {
66         if (offset > INT64_MAX - c->pos)
67             return -1;
68         offset += c->pos;
69     } else if (whence == SEEK_END) {
70         if (offset > INT64_MAX - c->filesize)
71             return -1;
72         offset += c->filesize;
73     }
74     if (offset < 0 || offset > c->filesize)
75         return -1;
76     c->pos = offset;
77     return 0;
78 }
79
80 // Ensure we don't loop forever
81 const uint32_t maxiteration = 8096;
82
83 static const uint64_t FUZZ_TAG = 0x4741542D5A5A5546ULL;
84
85 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
86     const uint64_t fuzz_tag = FUZZ_TAG;
87     uint32_t it = 0;
88     AVFormatContext *avfmt = avformat_alloc_context();
89     AVPacket pkt;
90     char filename[1025] = {0};
91     AVIOContext *fuzzed_pb = NULL;
92     uint8_t *io_buffer;
93     int io_buffer_size = 32768;
94     int64_t filesize   = size;
95     IOContext opaque;
96     static int c;
97     int seekable = 0;
98     int ret;
99
100     if (!c) {
101         av_register_all();
102         avcodec_register_all();
103         av_log_set_level(AV_LOG_PANIC);
104         c=1;
105     }
106
107     if (!avfmt)
108         error("Failed avformat_alloc_context()");
109
110     if (size > 2048) {
111         GetByteContext gbc;
112         memcpy (filename, data + size - 1024, 1024);
113         bytestream2_init(&gbc, data + size - 2048, 1024);
114         size -= 2048;
115
116         io_buffer_size = bytestream2_get_le32(&gbc) & 0xFFFFFFF;
117         seekable       = bytestream2_get_byte(&gbc) & 1;
118         filesize       = bytestream2_get_le64(&gbc) & 0x7FFFFFFFFFFFFFFF;
119     }
120     io_buffer = av_malloc(io_buffer_size);
121     if (!io_buffer)
122         error("Failed to allocate io_buffer");
123
124     opaque.filesize = filesize;
125     opaque.pos      = 0;
126     opaque.fuzz     = data;
127     opaque.fuzz_size= size;
128     fuzzed_pb = avio_alloc_context(io_buffer, io_buffer_size, 0, &opaque,
129                                    io_read, NULL, seekable ? io_seek : NULL);
130     if (!fuzzed_pb)
131         error("avio_alloc_context failed");
132
133     avfmt->pb = fuzzed_pb;
134
135     ret = avformat_open_input(&avfmt, filename, NULL, NULL);
136     if (ret < 0) {
137         av_freep(&fuzzed_pb->buffer);
138         av_freep(&fuzzed_pb);
139         avformat_free_context(avfmt);
140         return 0;
141     }
142
143     ret = avformat_find_stream_info(avfmt, NULL);
144     if (ret < 0)
145         goto end;
146
147     av_init_packet(&pkt);
148
149     //TODO, test seeking
150
151     for(it = 0; it < maxiteration; it++) {
152         ret = av_read_frame(avfmt, &pkt);
153         if (ret < 0)
154             break;
155         av_packet_unref(&pkt);
156     }
157 end:
158     av_freep(&fuzzed_pb->buffer);
159     av_freep(&fuzzed_pb);
160     avformat_close_input(&avfmt);
161
162     return 0;
163 }