git.sesse.net Git - ffmpeg/blob - 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 };