Statistics
| Branch: | Revision:

ffmpeg / libavformat / dfa.c @ 42315dab

History | View | Annotate | Download (3.33 KB)

1
/*
2
 * Chronomaster DFA Format Demuxer
3
 * Copyright (c) 2011 Konstantin Shishkov
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * Libav is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "libavutil/intreadwrite.h"
23
#include "avformat.h"
24

    
25
static int dfa_probe(AVProbeData *p)
26
{
27
    if (p->buf_size < 4 || AV_RL32(p->buf) != MKTAG('D', 'F', 'I', 'A'))
28
        return 0;
29

    
30
    return AVPROBE_SCORE_MAX;
31
}
32

    
33
static int dfa_read_header(AVFormatContext *s,
34
                           AVFormatParameters *ap)
35
{
36
    AVIOContext *pb = s->pb;
37
    AVStream *st;
38
    int frames;
39
    uint32_t mspf;
40

    
41
    if (avio_rl32(pb) != MKTAG('D', 'F', 'I', 'A')) {
42
        av_log(s, AV_LOG_ERROR, "Invalid magic for DFA\n");
43
        return AVERROR_INVALIDDATA;
44
    }
45
    avio_skip(pb, 2); // unused
46
    frames = avio_rl16(pb);
47

    
48
    st = av_new_stream(s, 0);
49
    if (!st)
50
        return AVERROR(ENOMEM);
51

    
52
    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
53
    st->codec->codec_id   = CODEC_ID_DFA;
54
    st->codec->width      = avio_rl16(pb);
55
    st->codec->height     = avio_rl16(pb);
56
    mspf = avio_rl32(pb);
57
    if (!mspf) {
58
        av_log(s, AV_LOG_WARNING, "Zero FPS reported, defaulting to 10\n");
59
        mspf = 100;
60
    }
61
    av_set_pts_info(st, 24, mspf, 1000);
62
    avio_skip(pb, 128 - 16); // padding
63
    st->duration = frames;
64

    
65
    return 0;
66
}
67

    
68
static int dfa_read_packet(AVFormatContext *s, AVPacket *pkt)
69
{
70
    AVIOContext *pb = s->pb;
71
    uint32_t frame_size;
72
    int ret, first = 1;
73

    
74
    if (pb->eof_reached)
75
        return AVERROR_EOF;
76

    
77
    if (av_get_packet(pb, pkt, 12) != 12)
78
        return AVERROR(EIO);
79
    while (!pb->eof_reached) {
80
        if (!first) {
81
            ret = av_append_packet(pb, pkt, 12);
82
            if (ret < 0) {
83
                av_free_packet(pkt);
84
                return ret;
85
            }
86
        } else
87
            first = 0;
88
        frame_size = AV_RL32(pkt->data + pkt->size - 8);
89
        if (frame_size > INT_MAX - 4) {
90
            av_log(s, AV_LOG_ERROR, "Too large chunk size: %d\n", frame_size);
91
            return AVERROR(EIO);
92
        }
93
        if (AV_RL32(pkt->data + pkt->size - 12) == MKTAG('E', 'O', 'F', 'R')) {
94
            if (frame_size) {
95
                av_log(s, AV_LOG_WARNING, "skipping %d bytes of end-of-frame marker chunk\n",
96
                       frame_size);
97
                avio_skip(pb, frame_size);
98
            }
99
            return 0;
100
        }
101
        ret = av_append_packet(pb, pkt, frame_size);
102
        if (ret < 0) {
103
            av_free_packet(pkt);
104
            return ret;
105
        }
106
    }
107

    
108
    return 0;
109
}
110

    
111
AVInputFormat ff_dfa_demuxer = {
112
    "dfa",
113
    NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
114
    0,
115
    dfa_probe,
116
    dfa_read_header,
117
    dfa_read_packet,
118
    .flags = AVFMT_GENERIC_INDEX,
119
};