flacdec: don't create an attached picture stream until we have all information.
[ffmpeg.git] / libavformat / flacdec.c
1 /*
2  * Raw FLAC demuxer
3  * Copyright (c) 2001 Fabrice Bellard
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 "libavcodec/flac.h"
23 #include "avformat.h"
24 #include "id3v2.h"
25 #include "internal.h"
26 #include "rawdec.h"
27 #include "oggdec.h"
28 #include "vorbiscomment.h"
29 #include "libavcodec/bytestream.h"
30
31 static int parse_picture(AVFormatContext *s, uint8_t *buf, int buf_size)
32 {
33     const CodecMime *mime = ff_id3v2_mime_tags;
34     enum  CodecID      id = CODEC_ID_NONE;
35     uint8_t mimetype[64], *desc = NULL, *data = NULL;
36     AVIOContext *pb = NULL;
37     AVStream *st;
38     int type, width, height;
39     int len, ret = 0;
40
41     pb = avio_alloc_context(buf, buf_size, 0, NULL, NULL, NULL, NULL);
42     if (!pb)
43         return AVERROR(ENOMEM);
44
45     /* read the picture type */
46     type      = avio_rb32(pb);
47     if (type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types) || type < 0) {
48         av_log(s, AV_LOG_ERROR, "Invalid picture type: %d.\n", type);
49         ret = AVERROR_INVALIDDATA;
50         goto fail;
51     }
52
53     /* picture mimetype */
54     len  = avio_rb32(pb);
55     if (len <= 0 ||
56         avio_read(pb, mimetype, FFMIN(len, sizeof(mimetype) - 1)) != len) {
57         av_log(s, AV_LOG_ERROR, "Could not read mimetype from an attached "
58                "picture.\n");
59         ret = AVERROR_INVALIDDATA;
60         goto fail;
61     }
62     mimetype[len] = 0;
63
64     while (mime->id != CODEC_ID_NONE) {
65         if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
66             id = mime->id;
67             break;
68         }
69         mime++;
70     }
71     if (id == CODEC_ID_NONE) {
72         av_log(s, AV_LOG_ERROR, "Unknown attached picture mimetype: %s.\n",
73                mimetype);
74         ret = AVERROR_INVALIDDATA;
75         goto fail;
76     }
77
78     /* picture description */
79     len = avio_rb32(pb);
80     if (len > 0) {
81         if (!(desc = av_malloc(len + 1))) {
82             ret = AVERROR(ENOMEM);
83             goto fail;
84         }
85
86         if (avio_read(pb, desc, len) != len) {
87             ret = AVERROR(EIO);
88             goto fail;
89         }
90         desc[len] = 0;
91     }
92
93     /* picture metadata */
94     width  = avio_rb32(pb);
95     height = avio_rb32(pb);
96     avio_skip(pb, 8);
97
98     /* picture data */
99     len = avio_rb32(pb);
100     if (len <= 0) {
101         ret = AVERROR_INVALIDDATA;
102         goto fail;
103     }
104     if (!(data = av_malloc(len))) {
105         ret = AVERROR(ENOMEM);
106         goto fail;
107     }
108     if (avio_read(pb, data, len) != len) {
109         ret = AVERROR(EIO);
110         goto fail;
111     }
112
113     st = avformat_new_stream(s, NULL);
114     if (!st) {
115         ret = AVERROR(ENOMEM);
116         goto fail;
117     }
118
119     av_init_packet(&st->attached_pic);
120     st->attached_pic.data         = data;
121     st->attached_pic.size         = len;
122     st->attached_pic.destruct     = av_destruct_packet;
123     st->attached_pic.stream_index = st->index;
124     st->attached_pic.flags       |= AV_PKT_FLAG_KEY;
125
126     st->disposition      |= AV_DISPOSITION_ATTACHED_PIC;
127     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
128     st->codec->codec_id   = id;
129     st->codec->width      = width;
130     st->codec->height     = height;
131     av_dict_set(&st->metadata, "comment", ff_id3v2_picture_types[type], 0);
132     if (desc)
133         av_dict_set(&st->metadata, "title",   desc, AV_DICT_DONT_STRDUP_VAL);
134
135     av_freep(&pb);
136
137     return 0;
138
139 fail:
140     av_freep(&desc);
141     av_freep(&data);
142     av_freep(&pb);
143     return ret;
144
145 }
146
147 static int flac_read_header(AVFormatContext *s)
148 {
149     int ret, metadata_last=0, metadata_type, metadata_size, found_streaminfo=0;
150     uint8_t header[4];
151     uint8_t *buffer=NULL;
152     AVStream *st = avformat_new_stream(s, NULL);
153     if (!st)
154         return AVERROR(ENOMEM);
155     st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
156     st->codec->codec_id = CODEC_ID_FLAC;
157     st->need_parsing = AVSTREAM_PARSE_FULL;
158     /* the parameters will be extracted from the compressed bitstream */
159
160     /* if fLaC marker is not found, assume there is no header */
161     if (avio_rl32(s->pb) != MKTAG('f','L','a','C')) {
162         avio_seek(s->pb, -4, SEEK_CUR);
163         return 0;
164     }
165
166     /* process metadata blocks */
167     while (!s->pb->eof_reached && !metadata_last) {
168         avio_read(s->pb, header, 4);
169         avpriv_flac_parse_block_header(header, &metadata_last, &metadata_type,
170                                    &metadata_size);
171         switch (metadata_type) {
172         /* allocate and read metadata block for supported types */
173         case FLAC_METADATA_TYPE_STREAMINFO:
174         case FLAC_METADATA_TYPE_CUESHEET:
175         case FLAC_METADATA_TYPE_PICTURE:
176         case FLAC_METADATA_TYPE_VORBIS_COMMENT:
177             buffer = av_mallocz(metadata_size + FF_INPUT_BUFFER_PADDING_SIZE);
178             if (!buffer) {
179                 return AVERROR(ENOMEM);
180             }
181             if (avio_read(s->pb, buffer, metadata_size) != metadata_size) {
182                 av_freep(&buffer);
183                 return AVERROR(EIO);
184             }
185             break;
186         /* skip metadata block for unsupported types */
187         default:
188             ret = avio_skip(s->pb, metadata_size);
189             if (ret < 0)
190                 return ret;
191         }
192
193         if (metadata_type == FLAC_METADATA_TYPE_STREAMINFO) {
194             FLACStreaminfo si;
195             /* STREAMINFO can only occur once */
196             if (found_streaminfo) {
197                 av_freep(&buffer);
198                 return AVERROR_INVALIDDATA;
199             }
200             if (metadata_size != FLAC_STREAMINFO_SIZE) {
201                 av_freep(&buffer);
202                 return AVERROR_INVALIDDATA;
203             }
204             found_streaminfo = 1;
205             st->codec->extradata      = buffer;
206             st->codec->extradata_size = metadata_size;
207             buffer = NULL;
208
209             /* get codec params from STREAMINFO header */
210             avpriv_flac_parse_streaminfo(st->codec, &si, st->codec->extradata);
211
212             /* set time base and duration */
213             if (si.samplerate > 0) {
214                 avpriv_set_pts_info(st, 64, 1, si.samplerate);
215                 if (si.samples > 0)
216                     st->duration = si.samples;
217             }
218         } else if (metadata_type == FLAC_METADATA_TYPE_CUESHEET) {
219             uint8_t isrc[13];
220             uint64_t start;
221             const uint8_t *offset;
222             int i, chapters, track, ti;
223             if (metadata_size < 431)
224                 return AVERROR_INVALIDDATA;
225             offset = buffer + 395;
226             chapters = bytestream_get_byte(&offset) - 1;
227             if (chapters <= 0)
228                 return AVERROR_INVALIDDATA;
229             for (i = 0; i < chapters; i++) {
230                 if (offset + 36 - buffer > metadata_size)
231                     return AVERROR_INVALIDDATA;
232                 start = bytestream_get_be64(&offset);
233                 track = bytestream_get_byte(&offset);
234                 bytestream_get_buffer(&offset, isrc, 12);
235                 isrc[12] = 0;
236                 offset += 14;
237                 ti = bytestream_get_byte(&offset);
238                 if (ti <= 0) return AVERROR_INVALIDDATA;
239                 offset += ti * 12;
240                 avpriv_new_chapter(s, track, st->time_base, start, AV_NOPTS_VALUE, isrc);
241             }
242         } else if (metadata_type == FLAC_METADATA_TYPE_PICTURE) {
243             ret = parse_picture(s, buffer, metadata_size);
244             av_freep(&buffer);
245             if (ret < 0) {
246                 av_log(s, AV_LOG_ERROR, "Error parsing attached picture.\n");
247                 return ret;
248             }
249         } else {
250             /* STREAMINFO must be the first block */
251             if (!found_streaminfo) {
252                 av_freep(&buffer);
253                 return AVERROR_INVALIDDATA;
254             }
255             /* process supported blocks other than STREAMINFO */
256             if (metadata_type == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
257                 if (ff_vorbis_comment(s, &s->metadata, buffer, metadata_size)) {
258                     av_log(s, AV_LOG_WARNING, "error parsing VorbisComment metadata\n");
259                 }
260             }
261             av_freep(&buffer);
262         }
263     }
264
265     return 0;
266 }
267
268 static int flac_probe(AVProbeData *p)
269 {
270     uint8_t *bufptr = p->buf;
271     uint8_t *end    = p->buf + p->buf_size;
272
273     if(bufptr > end-4 || memcmp(bufptr, "fLaC", 4)) return 0;
274     else                                            return AVPROBE_SCORE_MAX/2;
275 }
276
277 AVInputFormat ff_flac_demuxer = {
278     .name           = "flac",
279     .long_name      = NULL_IF_CONFIG_SMALL("raw FLAC"),
280     .read_probe     = flac_probe,
281     .read_header    = flac_read_header,
282     .read_packet    = ff_raw_read_partial_packet,
283     .flags          = AVFMT_GENERIC_INDEX,
284     .extensions     = "flac",
285     .raw_codec_id   = CODEC_ID_FLAC,
286 };