FFmpeg: libavformat/id3v2enc.c Source File

FFmpeg

[フレーム]

libavformat

id3v2enc.c

Go to the documentation of this file.

1 /*

2 * ID3v2 header writer

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #include <stdint.h>

22 #include <string.h>

24 #include "libavutil/avstring.h"

25 #include "libavutil/dict.h"

26 #include "libavutil/intreadwrite.h"

27 #include "avformat.h"

28 #include "avio.h"

29 #include "avio_internal.h"

30 #include "id3v2.h"

32 #define PADDING_BYTES 10

34 static void id3v2_put_size(AVIOContext *pb, int size)

35 {

36 avio_w8(pb, size >> 21 & 0x7f);

37 avio_w8(pb, size >> 14 & 0x7f);

38 avio_w8(pb, size >> 7 & 0x7f);

39 avio_w8(pb, size & 0x7f);

40 }

42 static int string_is_ascii(const uint8_t *str)

43 {

44 while (*str && *str < 128) str++;

45 return !*str;

46 }

48 static void id3v2_encode_string(AVIOContext *pb, const uint8_t *str,

49 enum ID3v2Encoding enc)

50 {

51 int (*put)(AVIOContext*, const char*);

53 if (enc == ID3v2_ENCODING_UTF16BOM) {

54 avio_wl16(pb, 0xFEFF); /* BOM */

55 put = avio_put_str16le;

56 } else

57 put = avio_put_str;

59 put(pb, str);

60 }

62 /**

63 * Write a text frame with one (normal frames) or two (TXXX frames) strings

64 * according to encoding (only UTF-8 or UTF-16+BOM supported).

65 * @return number of bytes written or a negative error code.

66 */

67 static int id3v2_put_ttag(ID3v2EncContext *id3, AVIOContext *avioc, const char *str1, const char *str2,

68 uint32_t tag, enum ID3v2Encoding enc)

69 {

70 int len;

71 uint8_t *pb;

72 AVIOContext *dyn_buf;

73 if (avio_open_dyn_buf(&dyn_buf) < 0)

74 return AVERROR(ENOMEM);

76 /* check if the strings are ASCII-only and use UTF16 only if

77 * they're not */

78 if (enc == ID3v2_ENCODING_UTF16BOM && string_is_ascii(str1) &&

79 (!str2 || string_is_ascii(str2)))

80 enc = ID3v2_ENCODING_ISO8859;

82 avio_w8(dyn_buf, enc);

83 id3v2_encode_string(dyn_buf, str1, enc);

84 if (str2)

85 id3v2_encode_string(dyn_buf, str2, enc);

86 len = avio_close_dyn_buf(dyn_buf, &pb);

88 avio_wb32(avioc, tag);

89 /* ID3v2.3 frame size is not synchsafe */

90 if (id3->version == 3)

91 avio_wb32(avioc, len);

92 else

93 id3v2_put_size(avioc, len);

94 avio_wb16(avioc, 0);

95 avio_write(avioc, pb, len);

97 av_freep(&pb);

98 return len + ID3v2_HEADER_SIZE;

99 }

100

101 static int id3v2_check_write_tag(ID3v2EncContext *id3, AVIOContext *pb, AVDictionaryEntry *t,

102 const char table[][4], enum ID3v2Encoding enc)

103 {

104 uint32_t tag;

105 int i;

106

107 if (t->key[0] != 'T' || strlen(t->key) != 4)

108 return -1;

109 tag = AV_RB32(t->key);

110 for (i = 0; *table[i]; i++)

111 if (tag == AV_RB32(table[i]))

112 return id3v2_put_ttag(id3, pb, t->value, NULL, tag, enc);

113 return -1;

114 }

115

116 static void id3v2_3_metadata_split_date(AVDictionary **pm)

117 {

118 AVDictionaryEntry *mtag = NULL;

119 AVDictionary *dst = NULL;

120 const char *key, *value;

121 char year[5] = {0}, day_month[5] = {0};

122 int i;

123

124 while ((mtag = av_dict_get(*pm, "", mtag, AV_DICT_IGNORE_SUFFIX))) {

125 key = mtag->key;

126 if (!av_strcasecmp(key, "date")) {

127 /* split date tag using "YYYY-MM-DD" format into year and month/day segments */

128 value = mtag->value;

129 i = 0;

130 while (value[i] >= '0' && value[i] <= '9') i++;

131 if (value[i] == '0円' || value[i] == '-') {

132 av_strlcpy(year, value, sizeof(year));

133 av_dict_set(&dst, "TYER", year, 0);

134

135 if (value[i] == '-' &&

136 value[i+1] >= '0' && value[i+1] <= '1' &&

137 value[i+2] >= '0' && value[i+2] <= '9' &&

138 value[i+3] == '-' &&

139 value[i+4] >= '0' && value[i+4] <= '3' &&

140 value[i+5] >= '0' && value[i+5] <= '9' &&

141 (value[i+6] == '0円' || value[i+6] == ' ')) {

142 snprintf(day_month, sizeof(day_month), "%.2s%.2s", value + i + 4, value + i + 1);

143 av_dict_set(&dst, "TDAT", day_month, 0);

144 }

145 } else

146 av_dict_set(&dst, key, value, 0);

147 } else

148 av_dict_set(&dst, key, mtag->value, 0);

149 }

150 av_dict_free(pm);

151 *pm = dst;

152 }

153

154 void ff_id3v2_start(ID3v2EncContext *id3, AVIOContext *pb, int id3v2_version,

155 const char *magic)

156 {

157 id3->version = id3v2_version;

158

159 avio_wb32(pb, MKBETAG(magic[0], magic[1], magic[2], id3v2_version));

160 avio_w8(pb, 0);

161 avio_w8(pb, 0); /* flags */

162

163 /* reserve space for size */

164 id3->size_pos = avio_tell(pb);

165 avio_wb32(pb, 0);

166 }

167

168 static int write_metadata(AVIOContext *pb, AVDictionary **metadata,

169 ID3v2EncContext *id3, int enc)

170 {

171 AVDictionaryEntry *t = NULL;

172 int ret;

173

174 ff_metadata_conv(metadata, ff_id3v2_34_metadata_conv, NULL);

175 if (id3->version == 3)

176 id3v2_3_metadata_split_date(metadata);

177 else if (id3->version == 4)

178 ff_metadata_conv(metadata, ff_id3v2_4_metadata_conv, NULL);

179

180 while ((t = av_dict_get(*metadata, "", t, AV_DICT_IGNORE_SUFFIX))) {

181 if ((ret = id3v2_check_write_tag(id3, pb, t, ff_id3v2_tags, enc)) > 0) {

182 id3->len += ret;

183 continue;

184 }

185 if ((ret = id3v2_check_write_tag(id3, pb, t, id3->version == 3 ?

186 ff_id3v2_3_tags : ff_id3v2_4_tags, enc)) > 0) {

187 id3->len += ret;

188 continue;

189 }

190

191 /* unknown tag, write as TXXX frame */

192 if ((ret = id3v2_put_ttag(id3, pb, t->key, t->value, MKBETAG('T', 'X', 'X', 'X'), enc)) < 0)

193 return ret;

194 id3->len += ret;

195 }

196

197 return 0;

198 }

199

200 static int write_chapter(AVFormatContext *s, ID3v2EncContext *id3, int id, int enc)

201 {

202 const AVRational time_base = {1, 1000};

203 AVChapter *ch = s->chapters[id];

204 uint8_t *dyn_buf = NULL;

205 AVIOContext *dyn_bc = NULL;

206 char name[123];

207 int len, start, end, ret;

208

209 if ((ret = avio_open_dyn_buf(&dyn_bc)) < 0)

210 goto fail;

211

212 start = av_rescale_q(ch->start, ch->time_base, time_base);

213 end = av_rescale_q(ch->end, ch->time_base, time_base);

214

215 snprintf(name, 122, "ch%d", id);

216 id3->len += avio_put_str(dyn_bc, name);

217 avio_wb32(dyn_bc, start);

218 avio_wb32(dyn_bc, end);

219 avio_wb32(dyn_bc, 0xFFFFFFFFu);

220 avio_wb32(dyn_bc, 0xFFFFFFFFu);

221

222 if ((ret = write_metadata(dyn_bc, &ch->metadata, id3, enc)) < 0)

223 goto fail;

224

225 len = avio_close_dyn_buf(dyn_bc, &dyn_buf);

226 id3->len += 16 + ID3v2_HEADER_SIZE;

227

228 avio_wb32(s->pb, MKBETAG('C', 'H', 'A', 'P'));

229 avio_wb32(s->pb, len);

230 avio_wb16(s->pb, 0);

231 avio_write(s->pb, dyn_buf, len);

232

233 fail:

234 if (dyn_bc && !dyn_buf)

235 avio_close_dyn_buf(dyn_bc, &dyn_buf);

236 av_freep(&dyn_buf);

237

238 return ret;

239 }

240

241 int ff_id3v2_write_metadata(AVFormatContext *s, ID3v2EncContext *id3)

242 {

243 int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :

244 ID3v2_ENCODING_UTF8;

245 int i, ret;

246

247 if ((ret = write_metadata(s->pb, &s->metadata, id3, enc)) < 0)

248 return ret;

249

250 for (i = 0; i < s->nb_chapters; i++) {

251 if ((ret = write_chapter(s, id3, i, enc)) < 0)

252 return ret;

253 }

254

255 return 0;

256 }

257

258 int ff_id3v2_write_apic(AVFormatContext *s, ID3v2EncContext *id3, AVPacket *pkt)

259 {

260 AVStream *st = s->streams[pkt->stream_index];

261 AVDictionaryEntry *e;

262

263 AVIOContext *dyn_buf;

264 uint8_t *buf;

265 const CodecMime *mime = ff_id3v2_mime_tags;

266 const char *mimetype = NULL, *desc = "";

267 int enc = id3->version == 3 ? ID3v2_ENCODING_UTF16BOM :

268 ID3v2_ENCODING_UTF8;

269 int i, len, type = 0;

270

271 /* get the mimetype*/

272 while (mime->id != AV_CODEC_ID_NONE) {

273 if (mime->id == st->codec->codec_id) {

274 mimetype = mime->str;

275 break;

276 }

277 mime++;

278 }

279 if (!mimetype) {

280 av_log(s, AV_LOG_ERROR, "No mimetype is known for stream %d, cannot "

281 "write an attached picture.\n", st->index);

282 return AVERROR(EINVAL);

283 }

284

285 /* get the picture type */

286 e = av_dict_get(st->metadata, "comment", NULL, 0);

287 for (i = 0; e && i < FF_ARRAY_ELEMS(ff_id3v2_picture_types); i++) {

288 if (strstr(ff_id3v2_picture_types[i], e->value) == ff_id3v2_picture_types[i]) {

289 type = i;

290 break;

291 }

292 }

293

294 /* get the description */

295 if ((e = av_dict_get(st->metadata, "title", NULL, 0)))

296 desc = e->value;

297

298 /* use UTF16 only for non-ASCII strings */

299 if (enc == ID3v2_ENCODING_UTF16BOM && string_is_ascii(desc))

300 enc = ID3v2_ENCODING_ISO8859;

301

302 /* start writing */

303 if (avio_open_dyn_buf(&dyn_buf) < 0)

304 return AVERROR(ENOMEM);

305

306 avio_w8(dyn_buf, enc);

307 avio_put_str(dyn_buf, mimetype);

308 avio_w8(dyn_buf, type);

309 id3v2_encode_string(dyn_buf, desc, enc);

310 avio_write(dyn_buf, pkt->data, pkt->size);

311 len = avio_close_dyn_buf(dyn_buf, &buf);

312

313 avio_wb32(s->pb, MKBETAG('A', 'P', 'I', 'C'));

314 if (id3->version == 3)

315 avio_wb32(s->pb, len);

316 else

317 id3v2_put_size(s->pb, len);

318 avio_wb16(s->pb, 0);

319 avio_write(s->pb, buf, len);

320 av_freep(&buf);

321

322 id3->len += len + ID3v2_HEADER_SIZE;

323

324 return 0;

325 }

326

327 void ff_id3v2_finish(ID3v2EncContext *id3, AVIOContext *pb)

328 {

329 int64_t cur_pos;

330

331 /* adding an arbitrary amount of padding bytes at the end of the

332 * ID3 metadata fixes cover art display for some software (iTunes,

333 * Traktor, Serato, Torq) */

334 ffio_fill(pb, 0, PADDING_BYTES);

335 id3->len += PADDING_BYTES;

336

337 cur_pos = avio_tell(pb);

338 avio_seek(pb, id3->size_pos, SEEK_SET);

339 id3v2_put_size(pb, id3->len);

340 avio_seek(pb, cur_pos, SEEK_SET);

341 }

342

343 int ff_id3v2_write_simple(struct AVFormatContext *s, int id3v2_version,

344 const char *magic)

345 {

346 ID3v2EncContext id3 = { 0 };

347 int ret;

348

349 ff_id3v2_start(&id3, s->pb, id3v2_version, magic);

350 if ((ret = ff_id3v2_write_metadata(s, &id3)) < 0)

351 return ret;

352 ff_id3v2_finish(&id3, s->pb);

353

354 return 0;

355 }

Generated on Sat Jan 25 2014 19:52:02 for FFmpeg by doxygen 1.8.2