6acbb29a7595300b5eb7ea0f5ee57e69a7a5151e
[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         pos = avio_rl32(s->pb);
72         size = avio_rl32(s->pb);
73
74         avio_skip(s->pb, 8);
75         timestamp = avio_rl32(s->pb);
76
77         ret = av_add_index_entry(st, pos, timestamp, size, 0, 0);
78         if (ret < 0)
79             return ret;
80
81         avio_skip(s->pb, frame_type == AVMEDIA_TYPE_VIDEO ? 8: 4);
82     }
83
84     return 0;
85 }
86
87 static int parse_header(AVFormatContext *s)
88 {
89     IFVContext *ifv = s->priv_data;
90     uint32_t aud_magic;
91     uint32_t vid_magic;
92
93     avio_skip(s->pb, 0x34);
94     avpriv_dict_set_timestamp(&s->metadata, "creation_time", avio_rl32(s->pb) * 1000000LL);
95     avio_skip(s->pb, 0x24);
96
97     ifv->width = avio_rl16(s->pb);
98     ifv->height = avio_rl16(s->pb);
99
100     avio_skip(s->pb, 0x8);
101     vid_magic = avio_rl32(s->pb);
102
103     if (vid_magic != MKTAG('H','2','6','4'))
104         avpriv_request_sample(s, "Unknown video codec %x", vid_magic);
105
106     avio_skip(s->pb, 0x2c);
107     ifv->sample_rate = avio_rl32(s->pb);
108     aud_magic = avio_rl32(s->pb);
109
110     if (aud_magic == MKTAG('G','R','A','W')) {
111         ifv->is_audio_present = 1;
112     } else if (aud_magic == MKTAG('P','C','M','U')) {
113         ifv->is_audio_present = 0;
114     } else {
115         avpriv_request_sample(s, "Unknown audio codec %x", aud_magic);
116     }
117
118     avio_skip(s->pb, 0x44);
119     ifv->total_vframes = avio_rl32(s->pb);
120     ifv->total_aframes = avio_rl32(s->pb);
121
122     return 0;
123 }
124
125 static int ifv_read_header(AVFormatContext *s)
126 {
127     IFVContext *ifv = s->priv_data;
128     AVStream *st;
129     int ret;
130
131     ret = parse_header(s);
132     if (ret < 0)
133         return ret;
134
135     st = avformat_new_stream(s, NULL);
136     if (!st)
137         return AVERROR(ENOMEM);
138
139     st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
140     st->codecpar->codec_id = AV_CODEC_ID_H264;
141     st->codecpar->width = ifv->width;
142     st->codecpar->height = ifv->height;
143     st->start_time = 0;
144     ifv->video_stream_index = st->index;
145
146     avpriv_set_pts_info(st, 32, 1, 1000);
147
148     if (ifv->is_audio_present) {
149         st = avformat_new_stream(s, NULL);
150         if (!st)
151             return AVERROR(ENOMEM);
152
153         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
154         st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
155         st->codecpar->channels = 1;
156         st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
157         st->codecpar->sample_rate = ifv->sample_rate;
158         ifv->audio_stream_index = st->index;
159
160         avpriv_set_pts_info(st, 32, 1, 1000);
161     }
162
163     /*read video index*/
164     avio_seek(s->pb, 0xf8, SEEK_SET);
165
166     ret = read_index(s, AVMEDIA_TYPE_VIDEO, 0);
167     if (ret < 0)
168         return ret;
169
170     if (ifv->is_audio_present) {
171         /*read audio index*/
172         avio_seek(s->pb, 0x14918, SEEK_SET);
173
174         ret = read_index(s, AVMEDIA_TYPE_AUDIO, 0);
175         if (ret < 0)
176             return ret;
177     }
178
179     ifv->next_video_index = 0;
180     ifv->next_audio_index = 0;
181
182     return 0;
183 }
184
185 static int ifv_read_packet(AVFormatContext *s, AVPacket *pkt)
186 {
187     IFVContext *ifv = s->priv_data;
188     AVStream *st;
189     AVIndexEntry *ev, *ea, *e_next;
190     int ret;
191
192     ev = ea = e_next = NULL;
193
194     if (ifv->next_video_index < ifv->total_vframes) {
195         st = s->streams[ifv->video_stream_index];
196         if (ifv->next_video_index < st->nb_index_entries)
197             e_next = ev = &st->index_entries[ifv->next_video_index];
198     }
199
200     if (ifv->is_audio_present &&
201         ifv->next_audio_index < ifv->total_aframes) {
202         st = s->streams[ifv->audio_stream_index];
203         if (ifv->next_audio_index < st->nb_index_entries) {
204             ea = &st->index_entries[ifv->next_audio_index];
205             if (!ev || ea->timestamp < ev->timestamp)
206                 e_next = ea;
207         }
208     }
209
210     if (!ev) {
211         if (ifv->is_audio_present && !ea) {
212             /*read new video and audio indexes*/
213
214             ifv->next_video_index = ifv->total_vframes;
215             ifv->next_audio_index = ifv->total_aframes;
216
217             avio_skip(s->pb, 0x1c);
218             ifv->total_vframes += avio_rl32(s->pb);
219             ifv->total_aframes += avio_rl32(s->pb);
220             avio_skip(s->pb, 0xc);
221
222             if (avio_feof(s->pb))
223                 return AVERROR_EOF;
224
225             ret = read_index(s, AVMEDIA_TYPE_VIDEO, ifv->next_video_index);
226             if (ret < 0)
227                 return ret;
228
229             ret = read_index(s, AVMEDIA_TYPE_AUDIO, ifv->next_audio_index);
230             if (ret < 0)
231                 return ret;
232
233             return 0;
234
235         } else if (!ifv->is_audio_present) {
236             /*read new video index*/
237
238             ifv->next_video_index = ifv->total_vframes;
239
240             avio_skip(s->pb, 0x1c);
241             ifv->total_vframes += avio_rl32(s->pb);
242             avio_skip(s->pb, 0x10);
243
244             if (avio_feof(s->pb))
245                 return AVERROR_EOF;
246
247             ret = read_index(s, AVMEDIA_TYPE_VIDEO, ifv->next_video_index);
248             if (ret < 0)
249                 return ret;
250
251             return 0;
252         }
253     }
254
255     if (!e_next) return AVERROR_EOF;
256
257     avio_seek(s->pb, e_next->pos, SEEK_SET);
258     ret = av_get_packet(s->pb, pkt, e_next->size);
259     if (ret < 0)
260         return ret;
261
262     if (e_next == ev) {
263         ifv->next_video_index++;
264         pkt->stream_index = ifv->video_stream_index;
265     } else {
266         ifv->next_audio_index++;
267         pkt->stream_index = ifv->audio_stream_index;
268     }
269
270     pkt->pts = e_next->timestamp;
271     pkt->pos = e_next->pos;
272
273     return 0;
274 }
275
276 static int ifv_read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
277 {
278     IFVContext *ifv = s->priv_data;
279
280     for (unsigned i = 0; i < s->nb_streams; i++) {
281         int index = av_index_search_timestamp(s->streams[i], ts, AVSEEK_FLAG_ANY);
282         if (index < 0) {
283             ifv->next_video_index = ifv->total_vframes - 1;
284             ifv->next_audio_index = ifv->total_aframes - 1;
285             return 0;
286         }
287
288         if (i == ifv->video_stream_index) {
289             ifv->next_video_index = index;
290         } else {
291             ifv->next_audio_index = index;
292         }
293     }
294
295     return 0;
296 }
297
298 AVInputFormat ff_ifv_demuxer = {
299     .name           = "ifv",
300     .long_name      = NULL_IF_CONFIG_SMALL("IFV CCTV DVR"),
301     .priv_data_size = sizeof(IFVContext),
302     .extensions     = "ifv",
303     .read_probe     = ifv_probe,
304     .read_header    = ifv_read_header,
305     .read_packet    = ifv_read_packet,
306     .read_seek      = ifv_read_seek,
307 };