blob: 50193907be1fd25f3292e6ea105045b9f10eeebc
1 | /* |
2 | * DXA demuxer |
3 | * Copyright (c) 2007 Konstantin Shishkov |
4 | * |
5 | * This file is part of FFmpeg. |
6 | * |
7 | * FFmpeg 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 | * FFmpeg 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 FFmpeg; if not, write to the Free Software |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
20 | */ |
21 | |
22 | #include <inttypes.h> |
23 | |
24 | #include "libavutil/intreadwrite.h" |
25 | #include "avformat.h" |
26 | #include "internal.h" |
27 | #include "riff.h" |
28 | |
29 | #define DXA_EXTRA_SIZE 9 |
30 | |
31 | typedef struct DXAContext { |
32 | int frames; |
33 | int has_sound; |
34 | int bpc; |
35 | uint32_t bytes_left; |
36 | int64_t wavpos, vidpos; |
37 | int readvid; |
38 | }DXAContext; |
39 | |
40 | static int dxa_probe(AVProbeData *p) |
41 | { |
42 | int w, h; |
43 | if (p->buf_size < 15) |
44 | return 0; |
45 | w = AV_RB16(p->buf + 11); |
46 | h = AV_RB16(p->buf + 13); |
47 | /* check file header */ |
48 | if (p->buf[0] == 'D' && p->buf[1] == 'E' && |
49 | p->buf[2] == 'X' && p->buf[3] == 'A' && |
50 | w && w <= 2048 && h && h <= 2048) |
51 | return AVPROBE_SCORE_MAX; |
52 | else |
53 | return 0; |
54 | } |
55 | |
56 | static int dxa_read_header(AVFormatContext *s) |
57 | { |
58 | AVIOContext *pb = s->pb; |
59 | DXAContext *c = s->priv_data; |
60 | AVStream *st, *ast; |
61 | uint32_t tag; |
62 | int32_t fps; |
63 | int w, h; |
64 | int num, den; |
65 | int flags; |
66 | int ret; |
67 | |
68 | tag = avio_rl32(pb); |
69 | if (tag != MKTAG('D', 'E', 'X', 'A')) |
70 | return AVERROR_INVALIDDATA; |
71 | flags = avio_r8(pb); |
72 | c->frames = avio_rb16(pb); |
73 | if(!c->frames){ |
74 | av_log(s, AV_LOG_ERROR, "File contains no frames ???\n"); |
75 | return AVERROR_INVALIDDATA; |
76 | } |
77 | |
78 | fps = avio_rb32(pb); |
79 | if(fps > 0){ |
80 | den = 1000; |
81 | num = fps; |
82 | }else if (fps < 0){ |
83 | den = 100000; |
84 | num = -fps; |
85 | }else{ |
86 | den = 10; |
87 | num = 1; |
88 | } |
89 | w = avio_rb16(pb); |
90 | h = avio_rb16(pb); |
91 | c->has_sound = 0; |
92 | |
93 | st = avformat_new_stream(s, NULL); |
94 | if (!st) |
95 | return AVERROR(ENOMEM); |
96 | |
97 | // Parse WAV data header |
98 | if(avio_rl32(pb) == MKTAG('W', 'A', 'V', 'E')){ |
99 | uint32_t size, fsize; |
100 | c->has_sound = 1; |
101 | size = avio_rb32(pb); |
102 | c->vidpos = avio_tell(pb) + size; |
103 | avio_skip(pb, 16); |
104 | fsize = avio_rl32(pb); |
105 | |
106 | ast = avformat_new_stream(s, NULL); |
107 | if (!ast) |
108 | return AVERROR(ENOMEM); |
109 | ret = ff_get_wav_header(s, pb, ast->codecpar, fsize, 0); |
110 | if (ret < 0) |
111 | return ret; |
112 | if (ast->codecpar->sample_rate > 0) |
113 | avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate); |
114 | // find 'data' chunk |
115 | while(avio_tell(pb) < c->vidpos && !avio_feof(pb)){ |
116 | tag = avio_rl32(pb); |
117 | fsize = avio_rl32(pb); |
118 | if(tag == MKTAG('d', 'a', 't', 'a')) break; |
119 | avio_skip(pb, fsize); |
120 | } |
121 | c->bpc = (fsize + c->frames - 1) / c->frames; |
122 | if(ast->codecpar->block_align) |
123 | c->bpc = ((c->bpc + ast->codecpar->block_align - 1) / ast->codecpar->block_align) * ast->codecpar->block_align; |
124 | c->bytes_left = fsize; |
125 | c->wavpos = avio_tell(pb); |
126 | avio_seek(pb, c->vidpos, SEEK_SET); |
127 | } |
128 | |
129 | /* now we are ready: build format streams */ |
130 | st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; |
131 | st->codecpar->codec_id = AV_CODEC_ID_DXA; |
132 | st->codecpar->width = w; |
133 | st->codecpar->height = h; |
134 | av_reduce(&den, &num, den, num, (1UL<<31)-1); |
135 | avpriv_set_pts_info(st, 33, num, den); |
136 | /* flags & 0x80 means that image is interlaced, |
137 | * flags & 0x40 means that image has double height |
138 | * either way set true height |
139 | */ |
140 | if(flags & 0xC0){ |
141 | st->codecpar->height >>= 1; |
142 | } |
143 | c->readvid = !c->has_sound; |
144 | c->vidpos = avio_tell(pb); |
145 | s->start_time = 0; |
146 | s->duration = (int64_t)c->frames * AV_TIME_BASE * num / den; |
147 | av_log(s, AV_LOG_DEBUG, "%d frame(s)\n",c->frames); |
148 | |
149 | return 0; |
150 | } |
151 | |
152 | static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt) |
153 | { |
154 | DXAContext *c = s->priv_data; |
155 | int ret; |
156 | uint32_t size; |
157 | uint8_t buf[DXA_EXTRA_SIZE], pal[768+4]; |
158 | int pal_size = 0; |
159 | |
160 | if(!c->readvid && c->has_sound && c->bytes_left){ |
161 | c->readvid = 1; |
162 | avio_seek(s->pb, c->wavpos, SEEK_SET); |
163 | size = FFMIN(c->bytes_left, c->bpc); |
164 | ret = av_get_packet(s->pb, pkt, size); |
165 | pkt->stream_index = 1; |
166 | if(ret != size) |
167 | return AVERROR(EIO); |
168 | c->bytes_left -= size; |
169 | c->wavpos = avio_tell(s->pb); |
170 | return 0; |
171 | } |
172 | avio_seek(s->pb, c->vidpos, SEEK_SET); |
173 | while(!avio_feof(s->pb) && c->frames){ |
174 | uint32_t tag; |
175 | if ((ret = avio_read(s->pb, buf, 4)) != 4) { |
176 | av_log(s, AV_LOG_ERROR, "failed reading chunk type\n"); |
177 | return ret < 0 ? ret : AVERROR_INVALIDDATA; |
178 | } |
179 | tag = AV_RL32(buf); |
180 | switch (tag) { |
181 | case MKTAG('N', 'U', 'L', 'L'): |
182 | if(av_new_packet(pkt, 4 + pal_size) < 0) |
183 | return AVERROR(ENOMEM); |
184 | pkt->stream_index = 0; |
185 | if(pal_size) memcpy(pkt->data, pal, pal_size); |
186 | memcpy(pkt->data + pal_size, buf, 4); |
187 | c->frames--; |
188 | c->vidpos = avio_tell(s->pb); |
189 | c->readvid = 0; |
190 | return 0; |
191 | case MKTAG('C', 'M', 'A', 'P'): |
192 | pal_size = 768+4; |
193 | memcpy(pal, buf, 4); |
194 | avio_read(s->pb, pal + 4, 768); |
195 | break; |
196 | case MKTAG('F', 'R', 'A', 'M'): |
197 | if ((ret = avio_read(s->pb, buf + 4, DXA_EXTRA_SIZE - 4)) != DXA_EXTRA_SIZE - 4) { |
198 | av_log(s, AV_LOG_ERROR, "failed reading dxa_extra\n"); |
199 | return ret < 0 ? ret : AVERROR_INVALIDDATA; |
200 | } |
201 | size = AV_RB32(buf + 5); |
202 | if(size > 0xFFFFFF){ |
203 | av_log(s, AV_LOG_ERROR, "Frame size is too big: %"PRIu32"\n", |
204 | size); |
205 | return AVERROR_INVALIDDATA; |
206 | } |
207 | if(av_new_packet(pkt, size + DXA_EXTRA_SIZE + pal_size) < 0) |
208 | return AVERROR(ENOMEM); |
209 | memcpy(pkt->data + pal_size, buf, DXA_EXTRA_SIZE); |
210 | ret = avio_read(s->pb, pkt->data + DXA_EXTRA_SIZE + pal_size, size); |
211 | if(ret != size){ |
212 | av_packet_unref(pkt); |
213 | return AVERROR(EIO); |
214 | } |
215 | if(pal_size) memcpy(pkt->data, pal, pal_size); |
216 | pkt->stream_index = 0; |
217 | c->frames--; |
218 | c->vidpos = avio_tell(s->pb); |
219 | c->readvid = 0; |
220 | return 0; |
221 | default: |
222 | av_log(s, AV_LOG_ERROR, "Unknown tag %s\n", av_fourcc2str(tag)); |
223 | return AVERROR_INVALIDDATA; |
224 | } |
225 | } |
226 | return AVERROR_EOF; |
227 | } |
228 | |
229 | AVInputFormat ff_dxa_demuxer = { |
230 | .name = "dxa", |
231 | .long_name = NULL_IF_CONFIG_SMALL("DXA"), |
232 | .priv_data_size = sizeof(DXAContext), |
233 | .read_probe = dxa_probe, |
234 | .read_header = dxa_read_header, |
235 | .read_packet = dxa_read_packet, |
236 | }; |
237 |