avformat/ifv: Check for EOF in read_index()
[ffmpeg.git] / libavformat / ifv.c
1 /*
2  * IFV demuxer
3  *
4  * Copyright (c) 2019 Swaraj Hota
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include "avformat.h"
24 #include "internal.h"
25 #include "avio_internal.h"
26
27 typedef struct IFVContext {
28     uint32_t next_video_index;
29     uint32_t next_audio_index;
30     uint32_t total_vframes;
31     uint32_t total_aframes;
32
33     int width, height;
34     int is_audio_present;
35     int sample_rate;
36
37     int video_stream_index;
38     int audio_stream_index;
39 } IFVContext;
40
41 static int ifv_probe(const AVProbeData *p)
42 {
43     static const uint8_t ifv_magic[] = {0x11, 0xd2, 0xd3, 0xab, 0xba, 0xa9,
44         0xcf, 0x11, 0x8e, 0xe6, 0x00, 0xc0, 0x0c, 0x20, 0x53, 0x65, 0x44};
45
46     if (!memcmp(p->buf, ifv_magic, sizeof(ifv_magic)))
47         return AVPROBE_SCORE_MAX;
48
49     return 0;
50 }
51
52 static int read_index(AVFormatContext *s,
53                       enum AVMediaType frame_type,
54                       uint32_t start_index)
55 {
56     IFVContext *ifv = s->priv_data;
57     AVStream *st;
58     int64_t pos, size, timestamp;
59     uint32_t end_index, i;
60     int ret;
61
62     if (frame_type == AVMEDIA_TYPE_VIDEO) {
63         end_index = ifv->total_vframes;
64         st = s->streams[ifv->video_stream_index];
65     } else {
66         end_index = ifv->total_aframes;
67         st = s->streams[ifv->audio_stream_index];
68     }
69
70     for (i = start_index; i < end_index; i++) {
71         if (avio_feof(s->pb))
72             return AVERROR_EOF;
73         pos = avio_rl32(s->pb);
74         size = avio_rl32(s->pb);
75
76         avio_skip(s->pb, 8);
77         timestamp = avio_rl32(s->pb);
78
79         ret = av_add_index_entry(st, pos, timestamp, size, 0, 0);
80         if (ret < 0)
81             return ret;
82
83         avio_skip(s->pb, frame_type == AVMEDIA_TYPE_VIDEO ? 8: 4);
84     }
85
86     return 0;
87 }
88
89 static int parse_header(AVFormatContext *s)
90 {
91     IFVContext *ifv = s->priv_data;
92     uint32_t aud_magic;
93     uint32_t vid_magic;
94
95     avio_skip(s->pb, 0x34);
96     avpriv_dict_set_timestamp(&s->metadata, "creation_time", avio_rl32(s->pb) * 1000000LL);
97     avio_skip(s->pb, 0x24);
98
99     ifv->width = avio_rl16(s->pb);
100     ifv->height = avio_rl16(s->pb);
101
102     avio_skip(s->pb, 0x8);
103     vid_magic = avio_rl32(s->pb);
104
105     if (vid_magic != MKTAG('H','2','6','4'))
106         avpriv_request_sample(s, "Unknown video codec %x", vid_magic);
107
108     avio_skip(s->pb, 0x2c);
109     ifv->sample_rate = avio_rl32(s->pb);
110     aud_magic = avio_rl32(s->pb);
111
112     if (aud_magic == MKTAG('G','R','A','W')) {
113         ifv->is_audio_present = 1;
114     } else if (aud_magic == MKTAG('P','C','M','U')) {
115         ifv->is_audio_present = 0;
116     } else {
117         avpriv_request_sample(s, "Unknown audio codec %x", aud_magic);
118     }
119
120     avio_skip(s->pb, 0x44);
121     ifv->total_vframes = avio_rl32(s->pb);
122     ifv->total_aframes = avio_rl32(s->pb);
123
124     return 0;
125 }
126
127 static int ifv_read_header(AVFormatContext *s)
128 {
129     IFVContext *ifv = s->priv_data;
130     AVStream *st;
131     int ret;
132
133     ret = parse_header(s);
134     if (ret < 0)
135         return ret;
136
137     st = avformat_new_stream(s, NULL);
138     if (!st)
139         return AVERROR(ENOMEM);
140
141     st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
142     st->codecpar->codec_id = AV_CODEC_ID_H264;
143     st->codecpar->width = ifv->width;
144     st->codecpar->height = ifv->height;
145     st->start_time = 0;
146     ifv->video_stream_index = st->index;
147
148     avpriv_set_pts_info(st, 32, 1, 1000);
149
150     if (ifv->is_audio_present) {
151         st = avformat_new_stream(s, NULL);
152         if (!st)
153             return AVERROR(ENOMEM);
154
155         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
156         st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
157         st->codecpar->channels = 1;
158         st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
159         st->codecpar->sample_rate = ifv->sample_rate;
160         ifv->audio_stream_index = st->index;
161
162         avpriv_set_pts_info(st, 32, 1, 1000);
163     }
164
165     /*read video index*/
166     avio_seek(s->pb, 0xf8, SEEK_SET);
167
168     ret = read_index(s, AVMEDIA_TYPE_VIDEO, 0);
169     if (ret < 0)
170         return ret;
171
172     if (ifv->is_audio_present) {
173         /*read audio index*/
174         avio_seek(s->pb, 0x14918, SEEK_SET);
175
176         ret = read_index(s, AVMEDIA_TYPE_AUDIO, 0);
177         if (ret < 0)
178             return ret;
179     }
180
181     ifv->next_video_index = 0;
182     ifv->next_audio_index = 0;
183
184     return 0;
185 }
186
187 static int ifv_read_packet(AVFormatContext *s, AVPacket *pkt)
188 {
189     IFVContext *ifv = s->priv_data;
190     AVStream *st;
191     AVIndexEntry *ev, *ea, *e_next;
192     int ret;
193
194     ev = ea = e_next = NULL;
195
196     if (ifv->next_video_index < ifv->total_vframes) {
197         st = s->streams[ifv->video_stream_index];
198         if (ifv->next_video_index < st->nb_index_entries)
199             e_next = ev = &st->index_entries[ifv->next_video_index];
200     }
201
202     if (ifv->is_audio_present &&
203         ifv->next_audio_index < ifv->total_aframes) {
204         st = s->streams[ifv->audio_stream_index];
205         if (ifv->next_audio_index < st->nb_index_entries) {
206             ea = &st->index_entries[ifv->next_audio_index];
207             if (!ev || ea->timestamp < ev->timestamp)
208                 e_next = ea;
209         }
210     }
211
212     if (!ev) {
213         if (ifv->is_audio_present && !ea) {
214             /*read new video and audio indexes*/
215
216             ifv->next_video_index = ifv->total_vframes;
217             ifv->next_audio_index = ifv->total_aframes;
218
219             avio_skip(s->pb, 0x1c);
220             ifv->total_vframes += avio_rl32(s->pb);
221             ifv->total_aframes += avio_rl32(s->pb);
222             avio_skip(s->pb, 0xc);
223
224             if (avio_feof(s->pb))
225                 return AVERROR_EOF;
226
227             ret = read_index(s, AVMEDIA_TYPE_VIDEO, ifv->next_video_index);
228             if (ret < 0)
229                 return ret;
230
231             ret = read_index(s, AVMEDIA_TYPE_AUDIO, ifv->next_audio_index);
232             if (ret < 0)
233                 return ret;
234
235             return 0;
236
237         } else if (!ifv->is_audio_present) {
238             /*read new video index*/
239
240             ifv->next_video_index = ifv->total_vframes;
241
242             avio_skip(s->pb, 0x1c);
243             ifv->total_vframes += avio_rl32(s->pb);
244             avio_skip(s->pb, 0x10);
245
246             if (avio_feof(s->pb))
247                 return AVERROR_EOF;
248
249             ret = read_index(s, AVMEDIA_TYPE_VIDEO, ifv->next_video_index);
250             if (ret < 0)
251                 return ret;
252
253             return 0;
254         }
255     }
256
257     if (!e_next) return AVERROR_EOF;
258
259     avio_seek(s->pb, e_next->pos, SEEK_SET);
260     ret = av_get_packet(s->pb, pkt, e_next->size);
261     if (ret < 0)
262         return ret;
263
264     if (e_next == ev) {
265         ifv->next_video_index++;
266         pkt->stream_index = ifv->video_stream_index;
267     } else {
268         ifv->next_audio_index++;
269         pkt->stream_index = ifv->audio_stream_index;
270     }
271
272     pkt->pts = e_next->timestamp;
273     pkt->pos = e_next->pos;
274
275     return 0;
276 }
277
278 static int ifv_read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
279 {
280     IFVContext *ifv = s->priv_data;
281
282     for (unsigned i = 0; i < s->nb_streams; i++) {
283         int index = av_index_search_timestamp(s->streams[i], ts, AVSEEK_FLAG_ANY);
284         if (index < 0) {
285             ifv->next_video_index = ifv->total_vframes - 1;
286             ifv->next_audio_index = ifv->total_aframes - 1;
287             return 0;
288         }
289
290         if (i == ifv->video_stream_index) {
291             ifv->next_video_index = index;
292         } else {
293             ifv->next_audio_index = index;
294         }
295     }
296
297     return 0;
298 }
299
300 AVInputFormat ff_ifv_demuxer = {
301     .name           = "ifv",
302     .long_name      = NULL_IF_CONFIG_SMALL("IFV CCTV DVR"),
303     .priv_data_size = sizeof(IFVContext),
304     .extensions     = "ifv",
305     .read_probe     = ifv_probe,
306     .read_header    = ifv_read_header,
307     .read_packet    = ifv_read_packet,
308     .read_seek      = ifv_read_seek,
309 };