]> git.sesse.net Git - vlc/blob - modules/demux/flac.c
Fix typo
[vlc] / modules / demux / flac.c
1 /*****************************************************************************
2  * flac.c : FLAC demux module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001-2007 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
8  *          Laurent Aimar <fenrir@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
34 #include <vlc_demux.h>
35 #include <vlc_meta.h>
36 #include <vlc_input.h>
37 #include <vlc_codec.h>
38 #include <assert.h>
39 #include <vlc_charset.h>
40
41 /*****************************************************************************
42  * Module descriptor
43  *****************************************************************************/
44 static int  Open  ( vlc_object_t * );
45 static void Close ( vlc_object_t * );
46
47 vlc_module_begin();
48     set_description( N_("FLAC demuxer") );
49     set_capability( "demux", 155 );
50     set_category( CAT_INPUT );
51     set_subcategory( SUBCAT_INPUT_DEMUX );
52     set_callbacks( Open, Close );
53     add_shortcut( "flac" );
54 vlc_module_end();
55
56 /*****************************************************************************
57  * Local prototypes
58  *****************************************************************************/
59 static int Demux  ( demux_t * );
60 static int Control( demux_t *, int, va_list );
61
62 static int  ReadMeta( demux_t *, uint8_t **pp_streaminfo, int *pi_streaminfo );
63
64 struct demux_sys_t
65 {
66     bool  b_start;
67     es_out_id_t *p_es;
68
69     /* Packetizer */
70     decoder_t *p_packetizer;
71
72     vlc_meta_t *p_meta;
73     audio_replay_gain_t replay_gain;
74
75     int64_t i_time_offset;
76     int64_t i_pts;
77     int64_t i_pts_start;
78
79     int64_t i_length; /* Length from stream info */
80     int64_t i_data_pos;
81
82     /* */
83     int         i_seekpoint;
84     seekpoint_t **seekpoint;
85
86     /* */
87     int                i_attachments;
88     input_attachment_t **attachments;
89     int                i_cover_idx;
90     int                i_cover_score;
91 };
92
93 #define STREAMINFO_SIZE 38
94 #define FLAC_PACKET_SIZE 16384
95
96 /*****************************************************************************
97  * Open: initializes ES structures
98  *****************************************************************************/
99 static int Open( vlc_object_t * p_this )
100 {
101     demux_t     *p_demux = (demux_t*)p_this;
102     demux_sys_t *p_sys;
103     const uint8_t *p_peek;
104     uint8_t     *p_streaminfo;
105     int         i_streaminfo;
106
107     /* Have a peep at the show. */
108     if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC;
109
110     if( p_peek[0]!='f' || p_peek[1]!='L' || p_peek[2]!='a' || p_peek[3]!='C' )
111     {
112         if( !p_demux->b_force ) return VLC_EGENERIC;
113
114         /* User forced */
115         msg_Err( p_demux, "this doesn't look like a flac stream, "
116                  "continuing anyway" );
117     }
118
119     p_demux->pf_demux   = Demux;
120     p_demux->pf_control = Control;
121     p_demux->p_sys      = p_sys = malloc( sizeof( demux_sys_t ) );
122     p_sys->b_start = true;
123     p_sys->p_meta = NULL;
124     memset( &p_sys->replay_gain, 0, sizeof(p_sys->replay_gain) );
125     p_sys->i_length = 0;
126     p_sys->i_time_offset = 0;
127     p_sys->i_pts = 0;
128     p_sys->i_pts_start = 0;
129     p_sys->p_es = NULL;
130     TAB_INIT( p_sys->i_seekpoint, p_sys->seekpoint );
131     TAB_INIT( p_sys->i_attachments, p_sys->attachments);
132     p_sys->i_cover_idx = 0;
133     p_sys->i_cover_score = 0;
134
135     /* We need to read and store the STREAMINFO metadata */
136     if( ReadMeta( p_demux, &p_streaminfo, &i_streaminfo ) )
137     {
138         free( p_sys );
139         return VLC_EGENERIC;
140     }
141
142     /* Load the FLAC packetizer */
143     INIT_APACKETIZER( p_sys->p_packetizer, 'f', 'l', 'a', 'c' );
144
145     /* Store STREAMINFO for the decoder and packetizer */
146     p_streaminfo[4] |= 0x80; /* Fake this as the last metadata block */
147     p_sys->p_packetizer->fmt_in.i_extra = i_streaminfo;
148     p_sys->p_packetizer->fmt_in.p_extra = p_streaminfo;
149
150     p_sys->p_packetizer->p_module =
151         module_Need( p_sys->p_packetizer, "packetizer", NULL, 0 );
152     if( !p_sys->p_packetizer->p_module )
153     {
154         free( p_sys->p_packetizer->fmt_in.p_extra );
155         vlc_object_release( p_sys->p_packetizer );
156
157         msg_Err( p_demux, "cannot find flac packetizer" );
158         return VLC_EGENERIC;
159     }
160
161     if( p_sys->i_cover_idx < p_sys->i_attachments )
162     {
163         char psz_url[128];
164         if( !p_sys->p_meta )
165             p_sys->p_meta = vlc_meta_New();
166         snprintf( psz_url, sizeof(psz_url), "attachment://%s",
167                   p_sys->attachments[p_sys->i_cover_idx]->psz_name );
168         vlc_meta_Set( p_sys->p_meta, vlc_meta_ArtworkURL, psz_url );
169     }
170     vlc_audio_replay_gain_MergeFromMeta( &p_sys->replay_gain, p_sys->p_meta );
171     return VLC_SUCCESS;
172 }
173
174 /*****************************************************************************
175  * Close: frees unused data
176  *****************************************************************************/
177 static void Close( vlc_object_t * p_this )
178 {
179     demux_t     *p_demux = (demux_t*)p_this;
180     demux_sys_t *p_sys = p_demux->p_sys;
181
182     TAB_CLEAN( p_sys->i_seekpoint, p_sys->seekpoint );
183
184     int i;
185     for( i = 0; i < p_sys->i_attachments; i++ )
186         free( p_sys->attachments[i] );
187     TAB_CLEAN( p_sys->i_attachments, p_sys->attachments);
188
189     /* Unneed module */
190     module_Unneed( p_sys->p_packetizer, p_sys->p_packetizer->p_module );
191
192     free( p_sys->p_packetizer->fmt_in.p_extra );
193
194     /* Delete the decoder */
195     vlc_object_release( p_sys->p_packetizer );
196     if( p_sys->p_meta )
197         vlc_meta_Delete( p_sys->p_meta );
198     free( p_sys );
199 }
200
201 /*****************************************************************************
202  * Demux: reads and demuxes data packets
203  *****************************************************************************
204  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
205  *****************************************************************************/
206 static int Demux( demux_t *p_demux )
207 {
208     demux_sys_t *p_sys = p_demux->p_sys;
209     block_t     *p_block_in, *p_block_out;
210
211     if( !( p_block_in = stream_Block( p_demux->s, FLAC_PACKET_SIZE ) ) )
212         return 0;
213
214     p_block_in->i_pts = p_block_in->i_dts = p_sys->b_start ? 1 : 0;
215     p_sys->b_start = false;
216
217     while( (p_block_out = p_sys->p_packetizer->pf_packetize(
218                 p_sys->p_packetizer, &p_block_in )) )
219     {
220         while( p_block_out )
221         {
222             block_t *p_next = p_block_out->p_next;
223
224             p_block_out->p_next = NULL;
225
226             if( p_sys->p_es == NULL )
227             {
228                 p_sys->p_packetizer->fmt_out.b_packetized = true;
229                 p_sys->p_packetizer->fmt_out.audio_replay_gain = p_sys->replay_gain;
230                 p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out);
231             }
232
233             /* set PCR */
234             if( p_block_out->i_dts >= p_sys->i_pts_start )
235                 es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block_out->i_dts );
236             else
237                 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
238
239             p_sys->i_pts = p_block_out->i_dts;
240             es_out_Send( p_demux->out, p_sys->p_es, p_block_out );
241
242             p_block_out = p_next;
243         }
244     }
245     return 1;
246 }
247
248 /*****************************************************************************
249  * Control:
250  *****************************************************************************/
251 static int64_t ControlGetLength( demux_t *p_demux )
252 {
253     demux_sys_t *p_sys = p_demux->p_sys;
254     const int64_t i_size = stream_Size(p_demux->s) - p_sys->i_data_pos;
255     int64_t i_length = p_sys->i_length;
256     int i;
257
258     /* Try to fix length using seekpoint and current size for truncated file */
259     for( i = p_sys->i_seekpoint-1; i >= 0; i-- )
260     {
261         seekpoint_t *s = p_sys->seekpoint[i];
262         if( s->i_byte_offset <= i_size )
263         {
264             if( i+1 < p_sys->i_seekpoint )
265             {
266                 /* Broken file */
267                 seekpoint_t *n = p_sys->seekpoint[i+1];
268                 assert( n->i_byte_offset != s->i_byte_offset); /* Should be ensured by ParseSeekTable */
269                 i_length = s->i_time_offset + (n->i_time_offset-s->i_time_offset) * (i_size-s->i_byte_offset) / (n->i_byte_offset-s->i_byte_offset);
270             }
271             break;
272         }
273     }
274     return i_length;
275 }
276
277 static int64_t ControlGetTime( demux_t *p_demux )
278 {
279     demux_sys_t *p_sys = p_demux->p_sys;
280     return __MAX(p_sys->i_pts, p_sys->i_pts_start) + p_sys->i_time_offset;
281 }
282
283 static int ControlSetTime( demux_t *p_demux, int64_t i_time )
284 {
285     demux_sys_t *p_sys = p_demux->p_sys;
286     int64_t i_next_time;
287     int64_t i_next_offset;
288     int64_t i_delta_time;
289     int64_t i_delta_offset;
290     bool b_seekable;
291     int i;
292
293     /* */
294     stream_Control( p_demux->s, STREAM_CAN_SEEK, &b_seekable );
295     if( !b_seekable )
296         return VLC_EGENERIC;
297
298     /* */
299     assert( p_sys->i_seekpoint > 0 );   /* ReadMeta ensure at least (0,0) */
300     for( i = p_sys->i_seekpoint-1; i >= 0; i-- )
301     {
302         if( p_sys->seekpoint[i]->i_time_offset <= i_time )
303             break;
304     }
305     if( i+1 < p_sys->i_seekpoint )
306     {
307         i_next_time   = p_sys->seekpoint[i+1]->i_time_offset;
308         i_next_offset = p_sys->seekpoint[i+1]->i_byte_offset;
309     }
310     else
311     {
312         i_next_time   = p_sys->i_length;
313         i_next_offset = stream_Size(p_demux->s)-p_sys->i_data_pos;
314     }
315     i_delta_time = i_time - p_sys->seekpoint[i]->i_time_offset;
316     i_delta_offset = (i_next_offset - p_sys->seekpoint[i]->i_byte_offset) * i_delta_time /
317                             (p_sys->seekpoint[i+1]->i_time_offset-p_sys->seekpoint[i]->i_time_offset);
318
319     /* XXX We do exact seek if it's not too far away(45s) */
320     if( i_delta_time < 45*INT64_C(1000000) )
321     {
322         if( stream_Seek( p_demux->s, p_sys->seekpoint[i]->i_byte_offset+p_sys->i_data_pos ) )
323             return VLC_EGENERIC;
324         p_sys->i_time_offset = p_sys->seekpoint[i]->i_time_offset - p_sys->i_pts;
325         p_sys->i_pts_start = p_sys->i_pts+i_delta_time;
326         es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME, p_sys->p_es, p_sys->i_pts_start );
327     }
328     else
329     {
330         if( stream_Seek( p_demux->s, p_sys->seekpoint[i]->i_byte_offset+p_sys->i_data_pos + i_delta_offset ) )
331             return VLC_EGENERIC;
332         p_sys->i_pts_start = p_sys->i_pts;
333         p_sys->i_time_offset = (p_sys->seekpoint[i]->i_time_offset+i_delta_time) - p_sys->i_pts;
334     }
335     return VLC_SUCCESS;
336 }
337
338 static int Control( demux_t *p_demux, int i_query, va_list args )
339 {
340     demux_sys_t *p_sys = p_demux->p_sys;
341
342     if( i_query == DEMUX_GET_META )
343     {
344         vlc_meta_t *p_meta = (vlc_meta_t *)va_arg( args, vlc_meta_t* );
345         if( p_demux->p_sys->p_meta )
346             vlc_meta_Merge( p_meta, p_demux->p_sys->p_meta );
347         return VLC_SUCCESS;
348     }
349     else if( i_query == DEMUX_HAS_UNSUPPORTED_META )
350     {
351         bool *pb_bool = (bool*)va_arg( args, bool* );
352         *pb_bool = true;
353         return VLC_SUCCESS;
354     }
355     else if( i_query == DEMUX_GET_LENGTH )
356     {
357         int64_t *pi64 = (int64_t*)va_arg( args, int64_t * );
358         *pi64 = ControlGetLength( p_demux );
359         return VLC_SUCCESS;
360     }
361     else if( i_query == DEMUX_SET_TIME )
362     {
363         int64_t i_time = (int64_t)va_arg( args, int64_t );
364         return ControlSetTime( p_demux, i_time );
365     }
366     else if( i_query == DEMUX_SET_POSITION )
367     {
368         const double f = (double)va_arg( args, double );
369         int64_t i_time = f * ControlGetLength( p_demux );
370         return ControlSetTime( p_demux, i_time );
371     }
372     else if( i_query == DEMUX_GET_TIME )
373     {
374         int64_t *pi64 = (int64_t*)va_arg( args, int64_t * );
375         *pi64 = ControlGetTime( p_demux );
376         return VLC_SUCCESS;
377     }
378     else if( i_query == DEMUX_GET_POSITION )
379     {
380         double *pf = (double*)va_arg( args, double * );
381         const int64_t i_length = ControlGetLength(p_demux);
382         if( i_length > 0 )
383             *pf = (double)ControlGetTime(p_demux) / (double)i_length;
384         else
385             *pf= 0.0;
386         return VLC_SUCCESS;
387     }
388     else if( i_query == DEMUX_GET_ATTACHMENTS )
389     {
390         input_attachment_t ***ppp_attach =
391             (input_attachment_t***)va_arg( args, input_attachment_t*** );
392         int *pi_int = (int*)va_arg( args, int * );
393         int i;
394
395         if( p_sys->i_attachments <= 0 )
396             return VLC_EGENERIC;
397
398         *pi_int = p_sys->i_attachments;;
399         *ppp_attach = malloc( sizeof(input_attachment_t**) * p_sys->i_attachments );
400         for( i = 0; i < p_sys->i_attachments; i++ )
401             (*ppp_attach)[i] = vlc_input_attachment_Duplicate( p_sys->attachments[i] );
402         return VLC_SUCCESS;
403     }
404
405     return demux_vaControlHelper( p_demux->s, p_sys->i_data_pos, -1,
406                                    8*0, 1, i_query, args );
407 }
408
409 enum
410 {
411     META_STREAMINFO = 0,
412     META_SEEKTABLE = 3,
413     META_COMMENT = 4,
414     META_PICTURE = 6,
415 };
416
417 static inline int Get24bBE( const uint8_t *p )
418 {
419     return (p[0] << 16)|(p[1] << 8)|(p[2]);
420 }
421
422 static void ParseStreamInfo( demux_t *p_demux, int *pi_rate, int64_t *pi_count, uint8_t *p_data, int i_data );
423 static void ParseSeekTable( demux_t *p_demux, const uint8_t *p_data, int i_data,
424                             int i_sample_rate );
425 static void ParseComment( demux_t *, const uint8_t *p_data, int i_data );
426 static void ParsePicture( demux_t *, const uint8_t *p_data, int i_data );
427
428 static int  ReadMeta( demux_t *p_demux, uint8_t **pp_streaminfo, int *pi_streaminfo )
429 {
430     demux_sys_t *p_sys = p_demux->p_sys;
431     int     i_peek;
432     const uint8_t *p_peek;
433     bool b_last;
434     int i_sample_rate;
435     int64_t i_sample_count;
436     seekpoint_t *s;
437
438     /* Read STREAMINFO */
439     i_peek = stream_Peek( p_demux->s, &p_peek, 8 );
440     if( (p_peek[4] & 0x7F) != META_STREAMINFO )
441     {
442         msg_Err( p_demux, "this isn't a STREAMINFO metadata block" );
443         return VLC_EGENERIC;
444     }
445     if( Get24bBE(&p_peek[5]) != (STREAMINFO_SIZE - 4) )
446     {
447         msg_Err( p_demux, "invalid size for a STREAMINFO metadata block" );
448         return VLC_EGENERIC;
449     }
450
451     *pi_streaminfo = 4 + STREAMINFO_SIZE;
452     *pp_streaminfo = malloc( 4 + STREAMINFO_SIZE );
453     if( *pp_streaminfo == NULL )
454         return VLC_EGENERIC;
455
456     if( stream_Read( p_demux->s, *pp_streaminfo, 4+STREAMINFO_SIZE ) != 4+STREAMINFO_SIZE )
457     {
458         msg_Err( p_demux, "failed to read STREAMINFO metadata block" );
459         free( *pp_streaminfo );
460         return VLC_EGENERIC;
461     }
462
463     /* */
464     ParseStreamInfo( p_demux, &i_sample_rate, &i_sample_count,  *pp_streaminfo, *pi_streaminfo );
465     if( i_sample_rate > 0 )
466         p_sys->i_length = i_sample_count * INT64_C(1000000)/i_sample_rate;
467
468     /* Be sure we have seekpoint 0 */
469     s = vlc_seekpoint_New();
470     s->i_time_offset = 0;
471     s->i_byte_offset = 0;
472     TAB_APPEND( p_sys->i_seekpoint, p_sys->seekpoint, s );
473
474     b_last = (*pp_streaminfo)[4]&0x80;
475     while( !b_last )
476     {
477         int i_len;
478         int i_type;
479
480         i_peek = stream_Peek( p_demux->s, &p_peek, 4 );
481         if( i_peek < 4 )
482             break;
483         b_last = p_peek[0]&0x80;
484         i_type = p_peek[0]&0x7f;
485         i_len  = Get24bBE( &p_peek[1] );
486
487         if( i_type == META_SEEKTABLE )
488         {
489             i_peek = stream_Peek( p_demux->s, &p_peek, 4+i_len );
490             if( i_peek == 4+i_len )
491                 ParseSeekTable( p_demux, p_peek, i_peek, i_sample_rate );
492         }
493         else if( i_type == META_COMMENT )
494         {
495             i_peek = stream_Peek( p_demux->s, &p_peek, 4+i_len );
496             if( i_peek == 4+i_len )
497                 ParseComment( p_demux, p_peek, i_peek );
498         }
499         else if( i_type == META_PICTURE )
500         {
501             i_peek = stream_Peek( p_demux->s, &p_peek, 4+i_len );
502             if( i_peek == 4+i_len )
503                 ParsePicture( p_demux, p_peek, i_peek );
504         }
505
506         if( stream_Read( p_demux->s, NULL, 4+i_len ) < 4+i_len )
507             break;
508     }
509
510     /* */
511     p_sys->i_data_pos = stream_Tell( p_demux->s );
512
513     return VLC_SUCCESS;
514 }
515 static void ParseStreamInfo( demux_t *p_demux, int *pi_rate, int64_t *pi_count, uint8_t *p_data, int i_data )
516 {
517     const int i_skip = 4+4;
518
519     *pi_rate = GetDWBE(&p_data[i_skip+4+6]) >> 12;
520     *pi_count = GetQWBE(&p_data[i_skip+4+6]) &  ((INT64_C(1)<<36)-1);
521 }
522
523 static void ParseSeekTable( demux_t *p_demux, const uint8_t *p_data, int i_data,
524                             int i_sample_rate )
525 {
526     demux_sys_t *p_sys = p_demux->p_sys;
527     seekpoint_t *s;
528     int i;
529
530     if( i_sample_rate <= 0 )
531         return;
532
533     /* */
534     for( i = 0; i < (i_data-4)/18; i++ )
535     {
536         const int64_t i_sample = GetQWBE( &p_data[4+18*i+0] );
537         int j;
538
539         if( i_sample < 0 || i_sample >= INT64_MAX )
540             continue;
541
542         s = vlc_seekpoint_New();
543         s->i_time_offset = i_sample * INT64_C(1000000)/i_sample_rate;
544         s->i_byte_offset = GetQWBE( &p_data[4+18*i+8] );
545
546         /* Check for duplicate entry */
547         for( j = 0; j < p_sys->i_seekpoint; j++ )
548         {
549             if( p_sys->seekpoint[j]->i_time_offset == s->i_time_offset ||
550                 p_sys->seekpoint[j]->i_byte_offset == s->i_byte_offset )
551             {
552                 vlc_seekpoint_Delete( s );
553                 s = NULL;
554                 break;
555             }
556         }
557         if( s )
558         {
559             TAB_APPEND( p_sys->i_seekpoint, p_sys->seekpoint, s );
560         }
561     }
562     /* TODO sort it by size and remove wrong seek entry (time not increasing) */
563 }
564
565 #define RM(x) do { i_data -= (x); p_data += (x); } while(0)
566 static void ParseComment( demux_t *p_demux, const uint8_t *p_data, int i_data )
567 {
568     demux_sys_t *p_sys = p_demux->p_sys;
569     int n;
570     int i_comment;
571
572     if( i_data < 8 )
573         return;
574
575     RM(4);
576
577     n = GetDWLE(p_data); RM(4);
578     if( n < 0 || n > i_data )
579         return;
580 #if 0
581     if( n > 0 )
582     {
583         /* TODO report vendor string ? */
584         char *psz_vendor = psz_vendor = strndup( p_data, n );
585         msg_Dbg( p_demux, "FLAC: COMMENT vendor length=%d vendor=%s\n", n, psz_vendor );
586         free( psz_vendor );
587     }
588 #endif
589     RM(n);
590
591     if( i_data < 4 )
592         return;
593
594     i_comment = GetDWLE(p_data); RM(4);
595     if( i_comment <= 0 )
596         return;
597
598     p_sys->p_meta = vlc_meta_New();
599
600     for( ; i_comment > 0; i_comment-- )
601     {
602         char *psz;
603         if( i_data < 4 )
604             break;
605         n = GetDWLE(p_data); RM(4);
606         if( n > i_data )
607             break;
608         if( n <= 0 )
609             continue;
610
611         psz = strndup( p_data, n );
612         RM(n);
613
614         EnsureUTF8( psz );
615
616 #define IF_EXTRACT(txt,var) \
617     if( !strncasecmp(psz, txt, strlen(txt)) ) \
618     { \
619         const char *oldval = vlc_meta_Get( p_sys->p_meta, vlc_meta_ ## var ); \
620         if( oldval ) \
621         { \
622             char * newval; \
623             if( asprintf( &newval, "%s,%s", oldval, &psz[strlen(txt)] ) == -1 ) \
624                 newval = NULL; \
625             vlc_meta_Set( p_sys->p_meta, vlc_meta_ ## var, newval ); \
626             free( newval ); \
627         } \
628         else \
629             vlc_meta_Set( p_sys->p_meta, vlc_meta_ ## var, &psz[strlen(txt)] ); \
630     }
631         IF_EXTRACT("TITLE=", Title )
632         else IF_EXTRACT("ALBUM=", Album )
633         else IF_EXTRACT("TRACKNUMBER=", TrackNumber )
634         else IF_EXTRACT("ARTIST=", Artist )
635         else IF_EXTRACT("COPYRIGHT=", Copyright )
636         else IF_EXTRACT("DESCRIPTION=", Description )
637         else IF_EXTRACT("GENRE=", Genre )
638         else IF_EXTRACT("DATE=", Date )
639         else if( strchr( psz, '=' ) )
640         {
641             /* generic (PERFORMER/LICENSE/ORGANIZATION/LOCATION/CONTACT/ISRC,
642              * undocumented tags and replay gain ) */
643             char *p = strchr( psz, '=' );
644             *p++ = '\0';
645             vlc_meta_AddExtra( p_sys->p_meta, psz, p );
646         }
647 #undef IF_EXTRACT
648         free( psz );
649     }
650 #undef RM
651 }
652
653 static void ParsePicture( demux_t *p_demux, const uint8_t *p_data, int i_data )
654 {
655     static const int pi_cover_score[] = {
656         0,      /* other */
657         2, 1,   /* icons */
658         10,     /* front cover */
659         9,      /* back cover */
660         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
661         6,      /* movie/video screen capture */
662         0,
663         7,      /* Illustration */
664         8,      /* Band/Artist logotype */
665         0,      /* Publisher/Studio */
666     };
667     demux_sys_t *p_sys = p_demux->p_sys;
668     int i_type;
669     int i_len;
670     char *psz_mime = NULL;
671     char *psz_description = NULL;
672     input_attachment_t *p_attachment;
673     char psz_name[128];
674
675     if( i_data < 4 + 3*4 )
676         return;
677 #define RM(x) do { i_data -= (x); p_data += (x); } while(0)
678     RM(4);
679
680     i_type = GetDWBE( p_data ); RM(4);
681     i_len = GetDWBE( p_data ); RM(4);
682     if( i_len < 0 || i_data < i_len + 4 )
683         goto error;
684     psz_mime = strndup( p_data, i_len ); RM(i_len);
685     i_len = GetDWBE( p_data ); RM(4);
686     if( i_len < 0 || i_data < i_len + 4*4 + 4)
687         goto error;
688     psz_description = strndup( p_data, i_len ); RM(i_len);
689     EnsureUTF8( psz_description );
690     RM(4*4);
691     i_len = GetDWBE( p_data ); RM(4);
692     if( i_len < 0 || i_len > i_data )
693         goto error;
694
695     msg_Dbg( p_demux, "FLAC: Picture type=%d mime=%s description='%s' file length=%d",
696              i_type, psz_mime, psz_description, i_len );
697
698     snprintf( psz_name, sizeof(psz_name), "picture%d", p_sys->i_attachments );
699     if( !strcasecmp( psz_mime, "image/jpeg" ) )
700         strcat( psz_name, ".jpg" );
701     else if( !strcasecmp( psz_mime, "image/png" ) )
702         strcat( psz_name, ".png" );
703
704     p_attachment = vlc_input_attachment_New( psz_name, psz_mime, psz_description,
705                                              p_data, i_data );
706     TAB_APPEND( p_sys->i_attachments, p_sys->attachments, p_attachment );
707
708     if( i_type >= 0 && i_type < sizeof(pi_cover_score)/sizeof(pi_cover_score[0]) &&
709         p_sys->i_cover_score < pi_cover_score[i_type] )
710     {
711         p_sys->i_cover_idx = p_sys->i_attachments-1;
712         p_sys->i_cover_score = pi_cover_score[i_type];
713     }
714 error:
715     free( psz_mime );
716     free( psz_description );
717 }
718 #undef RM
719