6fda35c1bef204888b92141669cba04d4cc8fa9d
[ffmpeg.git] / libavformat / takdec.c
1 /*
2  * Raw TAK demuxer
3  * Copyright (c) 2012 Paul B Mahol
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/crc.h"
23
24 #define BITSTREAM_READER_LE
25 #include "libavcodec/tak.h"
26
27 #include "apetag.h"
28 #include "avformat.h"
29 #include "avio_internal.h"
30 #include "internal.h"
31 #include "rawdec.h"
32
33 typedef struct TAKDemuxContext {
34     int     mlast_frame;
35     int64_t data_end;
36 } TAKDemuxContext;
37
38 static int tak_probe(AVProbeData *p)
39 {
40     if (!memcmp(p->buf, "tBaK", 4))
41         return AVPROBE_SCORE_EXTENSION;
42     return 0;
43 }
44
45 static unsigned long tak_check_crc(unsigned long checksum, const uint8_t *buf,
46                                    unsigned int len)
47 {
48     return av_crc(av_crc_get_table(AV_CRC_24_IEEE), checksum, buf, len);
49 }
50
51 static int tak_read_header(AVFormatContext *s)
52 {
53     TAKDemuxContext *tc = s->priv_data;
54     AVIOContext *pb     = s->pb;
55     GetBitContext gb;
56     AVStream *st;
57     uint8_t *buffer = NULL;
58     int ret;
59
60     st = avformat_new_stream(s, 0);
61     if (!st)
62         return AVERROR(ENOMEM);
63
64     st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
65     st->codecpar->codec_id   = AV_CODEC_ID_TAK;
66     st->need_parsing         = AVSTREAM_PARSE_FULL_RAW;
67
68     tc->mlast_frame = 0;
69     if (avio_rl32(pb) != MKTAG('t', 'B', 'a', 'K')) {
70         avio_seek(pb, -4, SEEK_CUR);
71         return 0;
72     }
73
74     while (!avio_feof(pb)) {
75         enum TAKMetaDataType type;
76         int size;
77
78         type = avio_r8(pb) & 0x7f;
79         size = avio_rl24(pb);
80
81         switch (type) {
82         case TAK_METADATA_STREAMINFO:
83         case TAK_METADATA_LAST_FRAME:
84         case TAK_METADATA_ENCODER:
85             if (size <= 3)
86                 return AVERROR_INVALIDDATA;
87
88             buffer = av_malloc(size - 3 + AV_INPUT_BUFFER_PADDING_SIZE);
89             if (!buffer)
90                 return AVERROR(ENOMEM);
91             memset(buffer + size - 3, 0, AV_INPUT_BUFFER_PADDING_SIZE);
92
93             ffio_init_checksum(pb, tak_check_crc, 0xCE04B7U);
94             if (avio_read(pb, buffer, size - 3) != size - 3) {
95                 av_freep(&buffer);
96                 return AVERROR(EIO);
97             }
98             if (ffio_get_checksum(s->pb) != avio_rb24(pb)) {
99                 av_log(s, AV_LOG_ERROR, "%d metadata block CRC error.\n", type);
100                 if (s->error_recognition & AV_EF_EXPLODE) {
101                     av_freep(&buffer);
102                     return AVERROR_INVALIDDATA;
103                 }
104             }
105
106             break;
107         case TAK_METADATA_MD5: {
108             uint8_t md5[16];
109             int i;
110
111             if (size != 19)
112                 return AVERROR_INVALIDDATA;
113             ffio_init_checksum(pb, tak_check_crc, 0xCE04B7U);
114             avio_read(pb, md5, 16);
115             if (ffio_get_checksum(s->pb) != avio_rb24(pb)) {
116                 av_log(s, AV_LOG_ERROR, "MD5 metadata block CRC error.\n");
117                 if (s->error_recognition & AV_EF_EXPLODE)
118                     return AVERROR_INVALIDDATA;
119             }
120
121             av_log(s, AV_LOG_VERBOSE, "MD5=");
122             for (i = 0; i < 16; i++)
123                 av_log(s, AV_LOG_VERBOSE, "%02x", md5[i]);
124             av_log(s, AV_LOG_VERBOSE, "\n");
125             break;
126         }
127         case TAK_METADATA_END: {
128             int64_t curpos = avio_tell(pb);
129
130             if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
131                 ff_ape_parse_tag(s);
132                 avio_seek(pb, curpos, SEEK_SET);
133             }
134
135             tc->data_end += curpos;
136             return 0;
137         }
138         default:
139             ret = avio_skip(pb, size);
140             if (ret < 0)
141                 return ret;
142         }
143
144         if (type == TAK_METADATA_STREAMINFO) {
145             TAKStreamInfo ti;
146
147             ret = avpriv_tak_parse_streaminfo(&ti, buffer, size -3);
148             if (ret < 0)
149                 return AVERROR_INVALIDDATA;
150             if (ti.samples > 0)
151                 st->duration = ti.samples;
152             st->codecpar->bits_per_coded_sample = ti.bps;
153             if (ti.ch_layout)
154                 st->codecpar->channel_layout = ti.ch_layout;
155             st->codecpar->sample_rate           = ti.sample_rate;
156             st->codecpar->channels              = ti.channels;
157             st->start_time                   = 0;
158             avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
159             st->codecpar->extradata             = buffer;
160             st->codecpar->extradata_size        = size - 3;
161             buffer                           = NULL;
162         } else if (type == TAK_METADATA_LAST_FRAME) {
163             if (size != 11)
164                 return AVERROR_INVALIDDATA;
165             init_get_bits8(&gb, buffer, size - 3);
166             tc->mlast_frame = 1;
167             tc->data_end    = get_bits64(&gb, TAK_LAST_FRAME_POS_BITS) +
168                               get_bits(&gb, TAK_LAST_FRAME_SIZE_BITS);
169             av_freep(&buffer);
170         } else if (type == TAK_METADATA_ENCODER) {
171             init_get_bits8(&gb, buffer, size - 3);
172             av_log(s, AV_LOG_VERBOSE, "encoder version: %0X\n",
173                    get_bits_long(&gb, TAK_ENCODER_VERSION_BITS));
174             av_freep(&buffer);
175         }
176     }
177
178     return AVERROR_EOF;
179 }
180
181 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
182 {
183     TAKDemuxContext *tc = s->priv_data;
184     int ret;
185
186     if (tc->mlast_frame) {
187         AVIOContext *pb = s->pb;
188         int64_t size, left;
189
190         left = tc->data_end - avio_tell(pb);
191         size = FFMIN(left, 1024);
192         if (size <= 0)
193             return AVERROR_EOF;
194
195         ret = av_get_packet(pb, pkt, size);
196         if (ret < 0)
197             return ret;
198
199         pkt->stream_index = 0;
200     } else {
201         ret = ff_raw_read_partial_packet(s, pkt);
202     }
203
204     return ret;
205 }
206
207 AVInputFormat ff_tak_demuxer = {
208     .name           = "tak",
209     .long_name      = NULL_IF_CONFIG_SMALL("raw TAK"),
210     .priv_data_size = sizeof(TAKDemuxContext),
211     .read_probe     = tak_probe,
212     .read_header    = tak_read_header,
213     .read_packet    = raw_read_packet,
214     .flags          = AVFMT_GENERIC_INDEX,
215     .extensions     = "tak",
216     .raw_codec_id   = AV_CODEC_ID_TAK,
217 };