Subversion Repositories Kolibri OS

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
6147 serge 1 
/*
2 
 * Raw FLAC picture parser
3 
 * Copyright (c) 2001 Fabrice Bellard
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 "libavutil/avassert.h"
23 
#include "avformat.h"
24 
#include "flac_picture.h"
25 
#include "id3v2.h"
26 
#include "internal.h"
27 
 
28 
int ff_flac_parse_picture(AVFormatContext *s, uint8_t *buf, int buf_size)
29 
{
30 
    const CodecMime *mime = ff_id3v2_mime_tags;
31 
    enum AVCodecID id = AV_CODEC_ID_NONE;
32 
    AVBufferRef *data = NULL;
33 
    uint8_t mimetype[64], *desc = NULL;
34 
    AVIOContext *pb = NULL;
35 
    AVStream *st;
36 
    int width, height, ret = 0;
37 
    int len;
38 
    unsigned int type;
39 
 
40 
    pb = avio_alloc_context(buf, buf_size, 0, NULL, NULL, NULL, NULL);
41 
    if (!pb)
42 
        return AVERROR(ENOMEM);
43 
 
44 
    /* read the picture type */
45 
    type = avio_rb32(pb);
46 
    if (type >= FF_ARRAY_ELEMS(ff_id3v2_picture_types)) {
47 
        av_log(s, AV_LOG_ERROR, "Invalid picture type: %d.\n", type);
48 
        if (s->error_recognition & AV_EF_EXPLODE) {
49 
            RETURN_ERROR(AVERROR_INVALIDDATA);
50 
        }
51 
        type = 0;
52 
    }
53 
 
54 
    /* picture mimetype */
55 
    len = avio_rb32(pb);
56 
    if (len <= 0 || len >= 64 ||
57 
        avio_read(pb, mimetype, FFMIN(len, sizeof(mimetype) - 1)) != len) {
58 
        av_log(s, AV_LOG_ERROR, "Could not read mimetype from an attached "
59 
               "picture.\n");
60 
        if (s->error_recognition & AV_EF_EXPLODE)
61 
            ret = AVERROR_INVALIDDATA;
62 
        goto fail;
63 
    }
64 
    av_assert0(len < sizeof(mimetype));
65 
    mimetype[len] = 0;
66 
 
67 
    while (mime->id != AV_CODEC_ID_NONE) {
68 
        if (!strncmp(mime->str, mimetype, sizeof(mimetype))) {
69 
            id = mime->id;
70 
            break;
71 
        }
72 
        mime++;
73 
    }
74 
    if (id == AV_CODEC_ID_NONE) {
75 
        av_log(s, AV_LOG_ERROR, "Unknown attached picture mimetype: %s.\n",
76 
               mimetype);
77 
        if (s->error_recognition & AV_EF_EXPLODE)
78 
            ret = AVERROR_INVALIDDATA;
79 
        goto fail;
80 
    }
81 
 
82 
    /* picture description */
83 
    len = avio_rb32(pb);
84 
    if (len > 0) {
85 
        if (!(desc = av_malloc(len + 1))) {
86 
            RETURN_ERROR(AVERROR(ENOMEM));
87 
        }
88 
 
89 
        if (avio_read(pb, desc, len) != len) {
90 
            av_log(s, AV_LOG_ERROR, "Error reading attached picture description.\n");
91 
            if (s->error_recognition & AV_EF_EXPLODE)
92 
                ret = AVERROR(EIO);
93 
            goto fail;
94 
        }
95 
        desc[len] = 0;
96 
    }
97 
 
98 
    /* picture metadata */
99 
    width  = avio_rb32(pb);
100 
    height = avio_rb32(pb);
101 
    avio_skip(pb, 8);
102 
 
103 
    /* picture data */
104 
    len = avio_rb32(pb);
105 
    if (len <= 0) {
106 
        av_log(s, AV_LOG_ERROR, "Invalid attached picture size: %d.\n", len);
107 
        if (s->error_recognition & AV_EF_EXPLODE)
108 
            ret = AVERROR_INVALIDDATA;
109 
        goto fail;
110 
    }
111 
    if (!(data = av_buffer_alloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
112 
        RETURN_ERROR(AVERROR(ENOMEM));
113 
    }
114 
    memset(data->data + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
115 
    if (avio_read(pb, data->data, len) != len) {
116 
        av_log(s, AV_LOG_ERROR, "Error reading attached picture data.\n");
117 
        if (s->error_recognition & AV_EF_EXPLODE)
118 
            ret = AVERROR(EIO);
119 
        goto fail;
120 
    }
121 
 
122 
    st = avformat_new_stream(s, NULL);
123 
    if (!st) {
124 
        RETURN_ERROR(AVERROR(ENOMEM));
125 
    }
126 
 
127 
    av_init_packet(&st->attached_pic);
128 
    st->attached_pic.buf          = data;
129 
    st->attached_pic.data         = data->data;
130 
    st->attached_pic.size         = len;
131 
    st->attached_pic.stream_index = st->index;
132 
    st->attached_pic.flags       |= AV_PKT_FLAG_KEY;
133 
 
134 
    st->disposition      |= AV_DISPOSITION_ATTACHED_PIC;
135 
    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
136 
    st->codec->codec_id   = id;
137 
    st->codec->width      = width;
138 
    st->codec->height     = height;
139 
    av_dict_set(&st->metadata, "comment", ff_id3v2_picture_types[type], 0);
140 
    if (desc)
141 
        av_dict_set(&st->metadata, "title", desc, AV_DICT_DONT_STRDUP_VAL);
142 
 
143 
    av_freep(&pb);
144 
 
145 
    return 0;
146 
 
147 
fail:
148 
    av_buffer_unref(&data);
149 
    av_freep(&desc);
150 
    av_freep(&pb);
151 
 
152 
    return ret;
153 
}