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
ifv_probe(const AVProbeData * p)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
read_index(AVFormatContext * s,enum AVMediaType frame_type,uint32_t start_index)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
parse_header(AVFormatContext * s)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
ifv_read_header(AVFormatContext * s)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
ifv_read_packet(AVFormatContext * s,AVPacket * pkt)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 uint64_t vframes, aframes;
214 if (ifv->is_audio_present && !ea) {
215 /*read new video and audio indexes*/
216
217 ifv->next_video_index = ifv->total_vframes;
218 ifv->next_audio_index = ifv->total_aframes;
219
220 avio_skip(s->pb, 0x1c);
221 vframes = ifv->total_vframes + (uint64_t)avio_rl32(s->pb);
222 aframes = ifv->total_aframes + (uint64_t)avio_rl32(s->pb);
223 if (vframes > INT_MAX || aframes > INT_MAX)
224 return AVERROR_INVALIDDATA;
225 ifv->total_vframes = vframes;
226 ifv->total_aframes = aframes;
227 avio_skip(s->pb, 0xc);
228
229 if (avio_feof(s->pb))
230 return AVERROR_EOF;
231
232 ret = read_index(s, AVMEDIA_TYPE_VIDEO, ifv->next_video_index);
233 if (ret < 0)
234 return ret;
235
236 ret = read_index(s, AVMEDIA_TYPE_AUDIO, ifv->next_audio_index);
237 if (ret < 0)
238 return ret;
239
240 return 0;
241
242 } else if (!ifv->is_audio_present) {
243 /*read new video index*/
244
245 ifv->next_video_index = ifv->total_vframes;
246
247 avio_skip(s->pb, 0x1c);
248 vframes = ifv->total_vframes + (uint64_t)avio_rl32(s->pb);
249 if (vframes > INT_MAX)
250 return AVERROR_INVALIDDATA;
251 ifv->total_vframes = vframes;
252 avio_skip(s->pb, 0x10);
253
254 if (avio_feof(s->pb))
255 return AVERROR_EOF;
256
257 ret = read_index(s, AVMEDIA_TYPE_VIDEO, ifv->next_video_index);
258 if (ret < 0)
259 return ret;
260
261 return 0;
262 }
263 }
264
265 if (!e_next) return AVERROR_EOF;
266
267 avio_seek(s->pb, e_next->pos, SEEK_SET);
268 ret = av_get_packet(s->pb, pkt, e_next->size);
269 if (ret < 0)
270 return ret;
271
272 if (e_next == ev) {
273 ifv->next_video_index++;
274 pkt->stream_index = ifv->video_stream_index;
275 } else {
276 ifv->next_audio_index++;
277 pkt->stream_index = ifv->audio_stream_index;
278 }
279
280 pkt->pts = e_next->timestamp;
281 pkt->pos = e_next->pos;
282
283 return 0;
284 }
285
ifv_read_seek(AVFormatContext * s,int stream_index,int64_t ts,int flags)286 static int ifv_read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
287 {
288 IFVContext *ifv = s->priv_data;
289
290 for (unsigned i = 0; i < s->nb_streams; i++) {
291 int index = av_index_search_timestamp(s->streams[i], ts, AVSEEK_FLAG_ANY);
292 if (index < 0) {
293 ifv->next_video_index = ifv->total_vframes - 1;
294 ifv->next_audio_index = ifv->total_aframes - 1;
295 return 0;
296 }
297
298 if (i == ifv->video_stream_index) {
299 ifv->next_video_index = index;
300 } else {
301 ifv->next_audio_index = index;
302 }
303 }
304
305 return 0;
306 }
307
308 AVInputFormat ff_ifv_demuxer = {
309 .name = "ifv",
310 .long_name = NULL_IF_CONFIG_SMALL("IFV CCTV DVR"),
311 .priv_data_size = sizeof(IFVContext),
312 .extensions = "ifv",
313 .read_probe = ifv_probe,
314 .read_header = ifv_read_header,
315 .read_packet = ifv_read_packet,
316 .read_seek = ifv_read_seek,
317 };
318