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