diff options
Diffstat (limited to 'recipes-multimedia/tinycompress/tinycompress/0001-tinycompress-Add-id3-decoding.patch')
-rwxr-xr-x | recipes-multimedia/tinycompress/tinycompress/0001-tinycompress-Add-id3-decoding.patch | 1001 |
1 files changed, 1001 insertions, 0 deletions
diff --git a/recipes-multimedia/tinycompress/tinycompress/0001-tinycompress-Add-id3-decoding.patch b/recipes-multimedia/tinycompress/tinycompress/0001-tinycompress-Add-id3-decoding.patch new file mode 100755 index 00000000..f578148a --- /dev/null +++ b/recipes-multimedia/tinycompress/tinycompress/0001-tinycompress-Add-id3-decoding.patch | |||
@@ -0,0 +1,1001 @@ | |||
1 | From 16f6b7a5baec41f18fde75fd311fb988e3c31810 Mon Sep 17 00:00:00 2001 | ||
2 | From: Shengjiu Wang <shengjiu.wang@nxp.com> | ||
3 | Date: Fri, 13 Jul 2018 18:13:24 +0800 | ||
4 | Subject: [PATCH] tinycompress: Add id3 decoding | ||
5 | |||
6 | Signed-off-by: Shengjiu Wang <shengjiu.wang@nxp.com> | ||
7 | --- | ||
8 | include/tinycompress/id3_tag_decode.h | 198 +++++++++++ | ||
9 | src/utils/Makefile.am | 2 +- | ||
10 | src/utils/cplay.c | 88 +++++ | ||
11 | src/utils/id3_tag_decode.c | 642 ++++++++++++++++++++++++++++++++++ | ||
12 | 4 files changed, 929 insertions(+), 1 deletion(-) | ||
13 | create mode 100644 include/tinycompress/id3_tag_decode.h | ||
14 | create mode 100644 src/utils/id3_tag_decode.c | ||
15 | |||
16 | diff --git a/include/tinycompress/id3_tag_decode.h b/include/tinycompress/id3_tag_decode.h | ||
17 | new file mode 100644 | ||
18 | index 0000000..1a911d7 | ||
19 | --- /dev/null | ||
20 | +++ b/include/tinycompress/id3_tag_decode.h | ||
21 | @@ -0,0 +1,198 @@ | ||
22 | +/* | ||
23 | + * Copyright (c) 2006-2017 Cadence Design Systems, Inc. | ||
24 | + * Copyright 2018 NXP | ||
25 | + * | ||
26 | + * Permission is hereby granted, free of charge, to any person obtaining | ||
27 | + * a copy of this software and associated documentation files (the | ||
28 | + * "Software"), to deal in the Software without restriction, including | ||
29 | + * without limitation the rights to use, copy, modify, merge, publish, | ||
30 | + * distribute, sublicense, and/or sell copies of the Software, and to | ||
31 | + * permit persons to whom the Software is furnished to do so, subject to | ||
32 | + * the following conditions: | ||
33 | + * | ||
34 | + * The above copyright notice and this permission notice shall be included | ||
35 | + * in all copies or substantial portions of the Software. | ||
36 | + * | ||
37 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
38 | + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
39 | + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | ||
40 | + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY | ||
41 | + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, | ||
42 | + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | ||
43 | + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
44 | + */ | ||
45 | + | ||
46 | +/****************************************************************** | ||
47 | + * file name : id3_tag_decode.h | ||
48 | + * | ||
49 | + * description : stores typedefs of structures specific to MP3 tag | ||
50 | + * | ||
51 | + * revision history: | ||
52 | + * 29 04 2004 DK creation | ||
53 | + *****************************************************************/ | ||
54 | + | ||
55 | +#ifndef ID3_TAG_DECODE_H | ||
56 | +#define ID3_TAG_DECODE_H | ||
57 | + | ||
58 | +typedef signed char WORD8; | ||
59 | +typedef signed char * pWORD8; | ||
60 | +typedef unsigned char UWORD8; | ||
61 | +typedef unsigned char * pUWORD8; | ||
62 | + | ||
63 | +typedef signed short WORD16; | ||
64 | +typedef signed short * pWORD16; | ||
65 | +typedef unsigned short UWORD16; | ||
66 | +typedef unsigned short * pUWORD16; | ||
67 | + | ||
68 | +typedef signed int WORD24; | ||
69 | +typedef signed int * pWORD24; | ||
70 | +typedef unsigned int UWORD24; | ||
71 | +typedef unsigned int * pUWORD24; | ||
72 | + | ||
73 | +typedef signed int WORD32; | ||
74 | +typedef signed int * pWORD32; | ||
75 | +typedef unsigned int UWORD32; | ||
76 | +typedef unsigned int * pUWORD32; | ||
77 | + | ||
78 | +typedef void VOID; | ||
79 | +typedef void * pVOID; | ||
80 | + | ||
81 | +typedef signed int BOOL; | ||
82 | +typedef unsigned int UBOOL; | ||
83 | +typedef signed int FLAG; | ||
84 | +typedef unsigned int UFLAG; | ||
85 | +typedef signed int LOOPIDX; | ||
86 | +typedef unsigned int ULOOPIDX; | ||
87 | +typedef signed int WORD; | ||
88 | +typedef unsigned int UWORD; | ||
89 | + | ||
90 | +#define MAX_TAG_FRAME_SIZE 100 | ||
91 | + | ||
92 | +#define ID3V1 (0x544147) /* 0x544147 is TAG in WORD8 */ | ||
93 | + | ||
94 | +#define ID3V2 (0x494433) /* 0x494433 is ID3 in WORD8 */ | ||
95 | + | ||
96 | +/* | ||
97 | + * structure corresponding to ID3 tag v1 header. | ||
98 | + * this structure has all the field corresponding to ID3 tag v1 header. | ||
99 | + */ | ||
100 | + | ||
101 | +typedef struct { | ||
102 | + WORD32 tag; // 3 bytes | ||
103 | + | ||
104 | + WORD16 version; // 2 bytes | ||
105 | + | ||
106 | + WORD8 flag; //1 byte | ||
107 | + | ||
108 | + WORD32 size; //4 bytes | ||
109 | + | ||
110 | +} id3_v2_header_struct; | ||
111 | + | ||
112 | +/* structure which will store the frame data and | ||
113 | + * also put a limit max data to be stored | ||
114 | + */ | ||
115 | +typedef struct { | ||
116 | + WORD8 frame_data[MAX_TAG_FRAME_SIZE]; | ||
117 | + | ||
118 | + WORD32 max_size; //4 bytes | ||
119 | + | ||
120 | + WORD16 tag_present; | ||
121 | + | ||
122 | + WORD16 exceeds_buffer_size; | ||
123 | + | ||
124 | +} id3_v2_frame_struct; | ||
125 | + | ||
126 | +/* | ||
127 | + * structure corresponding to ID3 tag v2. | ||
128 | + * this structure has some of the field corresponding to ID3 tag v2. | ||
129 | + * if user wants to read some more tag information from | ||
130 | + * the MP3 file, he can add that field in this structure and pass address | ||
131 | + * of that element to get_inf function in id3_tag_decode.c under the | ||
132 | + * corresponding field frame header. few fields which are needed are already | ||
133 | + * populated by reading from the TAG header. | ||
134 | + */ | ||
135 | +typedef struct { | ||
136 | + id3_v2_frame_struct album_movie_show_title; | ||
137 | + | ||
138 | + id3_v2_frame_struct composer_name; | ||
139 | + | ||
140 | + id3_v2_frame_struct content_type; | ||
141 | + | ||
142 | + id3_v2_frame_struct encoded_by; | ||
143 | + | ||
144 | + id3_v2_frame_struct lyricist_text_writer; | ||
145 | + | ||
146 | + id3_v2_frame_struct content_group_description; | ||
147 | + | ||
148 | + id3_v2_frame_struct title_songname_content_description; | ||
149 | + | ||
150 | + id3_v2_frame_struct medxa_type; | ||
151 | + | ||
152 | + id3_v2_frame_struct original_album_movie_show_title; | ||
153 | + | ||
154 | + id3_v2_frame_struct original_filename; | ||
155 | + | ||
156 | + id3_v2_frame_struct original_lyricist_text_writer; | ||
157 | + | ||
158 | + id3_v2_frame_struct original_artist_performer; | ||
159 | + | ||
160 | + id3_v2_frame_struct file_owner_licensee; | ||
161 | + | ||
162 | + id3_v2_frame_struct lead_performer_soloist; | ||
163 | + | ||
164 | + id3_v2_frame_struct publisher; | ||
165 | + | ||
166 | + id3_v2_frame_struct private_frame; | ||
167 | + | ||
168 | + id3_v2_frame_struct other_info; | ||
169 | + | ||
170 | + id3_v2_header_struct id3_v2_header; | ||
171 | + | ||
172 | + WORD32 header_end; | ||
173 | + | ||
174 | + WORD32 bytes_consumed; | ||
175 | + | ||
176 | +} id3v2_struct; | ||
177 | + | ||
178 | +/* | ||
179 | + * structure corresponding to ID3 tag v1. | ||
180 | + * this structure has all the field corresponding to ID3 tag v1. | ||
181 | + */ | ||
182 | +typedef struct { | ||
183 | + WORD8 song_title[30]; //30 word8acters | ||
184 | + | ||
185 | + WORD8 artist[30]; //30 word8acters | ||
186 | + | ||
187 | + WORD8 album[30]; //30 word8acters | ||
188 | + | ||
189 | + WORD8 year[4]; //4 word8acters | ||
190 | + | ||
191 | + WORD8 comment[30]; //30 word8acters | ||
192 | + | ||
193 | + WORD8 genre[1]; //1 byte | ||
194 | + | ||
195 | +} id3v1_struct; | ||
196 | + | ||
197 | +WORD32 get_info(const char *inp_buffer, | ||
198 | + unsigned int avail_inp, | ||
199 | + WORD32 tag_size, | ||
200 | + id3_v2_frame_struct *dest); | ||
201 | + | ||
202 | +WORD32 search_id3_v2(UWORD8 *buffer); | ||
203 | + | ||
204 | +WORD32 decode_id3_v2(const char *const buffer, | ||
205 | + id3v2_struct *id3v2, | ||
206 | + WORD32 continue_flag, | ||
207 | + WORD32 insize); | ||
208 | + | ||
209 | +WORD32 get_id3_v2_bytes(UWORD8 *buffer); | ||
210 | + | ||
211 | +WORD32 get_v1_info(UWORD8 *buffer, id3v1_struct *id3v1); | ||
212 | + | ||
213 | +WORD32 search_id3_v1(UWORD8 *buffer); | ||
214 | + | ||
215 | +WORD32 decode_id3_v1(UWORD8 *buffer, id3v1_struct *id3v1); | ||
216 | + | ||
217 | +void init_id3v2_field(id3v2_struct *id3v2); | ||
218 | + | ||
219 | +#endif | ||
220 | diff --git a/src/utils/Makefile.am b/src/utils/Makefile.am | ||
221 | index 1b996d4..e813689 100644 | ||
222 | --- a/src/utils/Makefile.am | ||
223 | +++ b/src/utils/Makefile.am | ||
224 | @@ -1,6 +1,6 @@ | ||
225 | bin_PROGRAMS = cplay crecord | ||
226 | |||
227 | -cplay_SOURCES = cplay.c | ||
228 | +cplay_SOURCES = cplay.c id3_tag_decode.c | ||
229 | crecord_SOURCES = crecord.c | ||
230 | |||
231 | cplay_CFLAGS = -I$(top_srcdir)/include | ||
232 | diff --git a/src/utils/cplay.c b/src/utils/cplay.c | ||
233 | index 87863a3..2a52b52 100644 | ||
234 | --- a/src/utils/cplay.c | ||
235 | +++ b/src/utils/cplay.c | ||
236 | @@ -72,6 +72,7 @@ | ||
237 | #include "sound/compress_params.h" | ||
238 | #include "tinycompress/tinycompress.h" | ||
239 | #include "tinycompress/tinymp3.h" | ||
240 | +#include "tinycompress/id3_tag_decode.h" | ||
241 | |||
242 | static int verbose; | ||
243 | static const unsigned int DEFAULT_CODEC_ID = SND_AUDIOCODEC_PCM; | ||
244 | @@ -245,12 +246,97 @@ int main(int argc, char **argv) | ||
245 | exit(EXIT_SUCCESS); | ||
246 | } | ||
247 | |||
248 | +void shift_buffer(char *buf, int buf_size, int bytes_consumed) | ||
249 | +{ | ||
250 | + int i; | ||
251 | + | ||
252 | + if (bytes_consumed <= 0) | ||
253 | + return; | ||
254 | + | ||
255 | + for (i = 0; i < buf_size - bytes_consumed; i++) | ||
256 | + buf[i] = buf[i + bytes_consumed]; | ||
257 | +} | ||
258 | + | ||
259 | +void parse_id3(FILE *file, int *offset) { | ||
260 | + /* ID3 tag specific declarations */ | ||
261 | + unsigned char id3_buf[128]; | ||
262 | + unsigned char id3v2_buf[4096]; | ||
263 | + signed int id3_v1_found = 0, id3_v1_decoded = 0; | ||
264 | + signed int id3_v2_found = 0, id3_v2_complete = 0; | ||
265 | + signed int i_bytes_consumed = 0; | ||
266 | + signed int i_fread_bytes; | ||
267 | + id3v1_struct id3v1; | ||
268 | + id3v2_struct id3v2; | ||
269 | + | ||
270 | + { | ||
271 | + fseek(file, -128, SEEK_END); | ||
272 | + fread(id3_buf, 1, 128, file); | ||
273 | + | ||
274 | + /* search for ID3V1 */ | ||
275 | + id3_v1_found = search_id3_v1(id3_buf + 0); | ||
276 | + if (id3_v1_found) { | ||
277 | + /* if ID3V1 is found, decode ID3V1 */ | ||
278 | + decode_id3_v1(id3_buf + 3, &id3v1); | ||
279 | + id3_v1_decoded = 1; | ||
280 | + } | ||
281 | + fseek(file, 0, SEEK_SET); | ||
282 | + } | ||
283 | + | ||
284 | + { | ||
285 | + signed int flag = 0; | ||
286 | + signed int continue_flag = 0; | ||
287 | + | ||
288 | + i_fread_bytes = fread(id3v2_buf, | ||
289 | + sizeof(char), 0x1000, file); | ||
290 | + | ||
291 | + /* search for ID3V2 */ | ||
292 | + id3_v2_found = | ||
293 | + search_id3_v2(id3v2_buf); | ||
294 | + | ||
295 | + if (id3_v2_found) { | ||
296 | + /* initialise the max fields */ | ||
297 | + init_id3v2_field(&id3v2); | ||
298 | + | ||
299 | + while (!id3_v2_complete && id3_v2_found) { | ||
300 | + /* if ID3V2 is found, decode ID3V2 */ | ||
301 | + id3_v2_complete = decode_id3_v2((const char *const)id3v2_buf, | ||
302 | + &id3v2, continue_flag, i_fread_bytes); | ||
303 | + | ||
304 | + if (!id3_v2_complete) { | ||
305 | + continue_flag = 1; | ||
306 | + i_bytes_consumed = id3v2.bytes_consumed; | ||
307 | + | ||
308 | + fseek(file, i_bytes_consumed, SEEK_SET); | ||
309 | + | ||
310 | + i_fread_bytes = fread(id3v2_buf, | ||
311 | + sizeof(unsigned char), 0x1000, file); | ||
312 | + if (i_fread_bytes <= 0) { | ||
313 | + return; | ||
314 | + } | ||
315 | + } | ||
316 | + } | ||
317 | + | ||
318 | + if (id3_v2_complete) { | ||
319 | + i_bytes_consumed = id3v2.bytes_consumed; | ||
320 | + fseek(file, i_bytes_consumed, SEEK_SET); | ||
321 | + } | ||
322 | + } | ||
323 | + } | ||
324 | + | ||
325 | + *offset = i_bytes_consumed; | ||
326 | +} | ||
327 | + | ||
328 | void get_codec_mp3(FILE *file, struct compr_config *config, | ||
329 | struct snd_codec *codec) | ||
330 | { | ||
331 | size_t read; | ||
332 | struct mp3_header header; | ||
333 | unsigned int channels, rate, bits; | ||
334 | + int offset = 0; | ||
335 | + | ||
336 | + parse_id3(file, &offset); | ||
337 | + | ||
338 | + fseek(file, offset, SEEK_SET); | ||
339 | |||
340 | read = fread(&header, 1, sizeof(header), file); | ||
341 | if (read != sizeof(header)) { | ||
342 | @@ -279,6 +365,8 @@ void get_codec_mp3(FILE *file, struct compr_config *config, | ||
343 | codec->level = 0; | ||
344 | codec->ch_mode = 0; | ||
345 | codec->format = 0; | ||
346 | + | ||
347 | + fseek(file, offset, SEEK_SET); | ||
348 | } | ||
349 | |||
350 | void get_codec_iec(FILE *file, struct compr_config *config, | ||
351 | diff --git a/src/utils/id3_tag_decode.c b/src/utils/id3_tag_decode.c | ||
352 | new file mode 100644 | ||
353 | index 0000000..393967a | ||
354 | --- /dev/null | ||
355 | +++ b/src/utils/id3_tag_decode.c | ||
356 | @@ -0,0 +1,642 @@ | ||
357 | +/* | ||
358 | + * Copyright (c) 2006-2017 Cadence Design Systems, Inc. | ||
359 | + * Copyright 2018 NXP | ||
360 | + * | ||
361 | + * Permission is hereby granted, free of charge, to any person obtaining | ||
362 | + * a copy of this software and associated documentation files (the | ||
363 | + * "Software"), to deal in the Software without restriction, including | ||
364 | + * without limitation the rights to use, copy, modify, merge, publish, | ||
365 | + * distribute, sublicense, and/or sell copies of the Software, and to | ||
366 | + * permit persons to whom the Software is furnished to do so, subject to | ||
367 | + * the following conditions: | ||
368 | + * | ||
369 | + * The above copyright notice and this permission notice shall be included | ||
370 | + * in all copies or substantial portions of the Software. | ||
371 | + * | ||
372 | + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
373 | + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
374 | + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | ||
375 | + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY | ||
376 | + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, | ||
377 | + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | ||
378 | + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | ||
379 | + */ | ||
380 | +#include <ctype.h> | ||
381 | +#include "tinycompress/id3_tag_decode.h" | ||
382 | + | ||
383 | +#define CHAR4(c1, c2, c3, c4) \ | ||
384 | + (int)(((unsigned char)(c1) << 24) | \ | ||
385 | + ((unsigned char)(c2) << 16) | \ | ||
386 | + ((unsigned char)(c3) << 8) | \ | ||
387 | + ((unsigned char)c4)) | ||
388 | + | ||
389 | +#ifndef MSVC_BUILD | ||
390 | +unsigned int umin(unsigned int a, unsigned int b) | ||
391 | +{ | ||
392 | + return (a < b ? a : b); | ||
393 | +} | ||
394 | + | ||
395 | +#else | ||
396 | +unsigned int umin(unsigned int a, unsigned int b) | ||
397 | +{ | ||
398 | + return (a < b ? a : b); | ||
399 | +} | ||
400 | +#endif | ||
401 | + | ||
402 | +/*********************************************************** | ||
403 | + * function name : display | ||
404 | + * | ||
405 | + * description : display ID3 tag contents. | ||
406 | + * | ||
407 | + * arguments : input parameters | ||
408 | + * | ||
409 | + * values returned : 0 | ||
410 | + ***********************************************************/ | ||
411 | + | ||
412 | +static void display2(const id3_v2_frame_struct * const src, | ||
413 | + int size, | ||
414 | + const char * const disp) | ||
415 | +{ | ||
416 | + int j; | ||
417 | + | ||
418 | + | ||
419 | + for (j = 0; j < size; j++) { | ||
420 | + int c = src->frame_data[j]; | ||
421 | + | ||
422 | + if (c) { | ||
423 | + if (!isprint(c)) | ||
424 | + break; | ||
425 | + } | ||
426 | + } | ||
427 | +} | ||
428 | + | ||
429 | +static VOID display1(WORD8 src[], WORD32 size, WORD8 disp[]) | ||
430 | +{ | ||
431 | + WORD32 j; | ||
432 | + | ||
433 | + for (j = 0; j < size ; j++) { | ||
434 | + int c = src[j]; | ||
435 | + | ||
436 | + if (c) { | ||
437 | + if (!isprint(c)) | ||
438 | + break; | ||
439 | + } | ||
440 | + } | ||
441 | +} | ||
442 | + | ||
443 | +/***************************************************************** | ||
444 | + * function name : init_id3_header | ||
445 | + * | ||
446 | + * description : initialise the max filed size of teh farem. | ||
447 | + * | ||
448 | + * arguments : input parameters | ||
449 | + * | ||
450 | + * values returned : 0 | ||
451 | + ****************************************************************/ | ||
452 | + | ||
453 | +VOID init_id3v2_field(id3v2_struct *id3v2) | ||
454 | +{ | ||
455 | + id3v2->album_movie_show_title.max_size = MAX_TAG_FRAME_SIZE; | ||
456 | + id3v2->composer_name.max_size = MAX_TAG_FRAME_SIZE; | ||
457 | + id3v2->content_type.max_size = MAX_TAG_FRAME_SIZE; | ||
458 | + id3v2->encoded_by.max_size = MAX_TAG_FRAME_SIZE; | ||
459 | + id3v2->lyricist_text_writer.max_size = MAX_TAG_FRAME_SIZE; | ||
460 | + id3v2->content_group_description.max_size = MAX_TAG_FRAME_SIZE; | ||
461 | + id3v2->title_songname_content_description.max_size = MAX_TAG_FRAME_SIZE; | ||
462 | + id3v2->medxa_type.max_size = MAX_TAG_FRAME_SIZE; | ||
463 | + id3v2->original_album_movie_show_title.max_size = MAX_TAG_FRAME_SIZE; | ||
464 | + id3v2->original_filename.max_size = MAX_TAG_FRAME_SIZE; | ||
465 | + id3v2->original_lyricist_text_writer.max_size = MAX_TAG_FRAME_SIZE; | ||
466 | + id3v2->original_artist_performer.max_size = MAX_TAG_FRAME_SIZE; | ||
467 | + id3v2->file_owner_licensee.max_size = MAX_TAG_FRAME_SIZE; | ||
468 | + id3v2->lead_performer_soloist.max_size = MAX_TAG_FRAME_SIZE; | ||
469 | + id3v2->publisher.max_size = MAX_TAG_FRAME_SIZE; | ||
470 | + id3v2->private_frame.max_size = MAX_TAG_FRAME_SIZE; | ||
471 | + id3v2->other_info.max_size = MAX_TAG_FRAME_SIZE; | ||
472 | + | ||
473 | + /* resetting the flag to indicate presese of frame */ | ||
474 | + id3v2->album_movie_show_title.tag_present = 0; | ||
475 | + id3v2->composer_name.tag_present = 0; | ||
476 | + id3v2->content_type.tag_present = 0; | ||
477 | + id3v2->encoded_by.tag_present = 0; | ||
478 | + id3v2->lyricist_text_writer.tag_present = 0; | ||
479 | + id3v2->content_group_description.tag_present = 0; | ||
480 | + id3v2->title_songname_content_description.tag_present = 0; | ||
481 | + id3v2->medxa_type.tag_present = 0; | ||
482 | + id3v2->original_album_movie_show_title.tag_present = 0; | ||
483 | + id3v2->original_filename.tag_present = 0; | ||
484 | + id3v2->original_lyricist_text_writer.tag_present = 0; | ||
485 | + id3v2->original_artist_performer.tag_present = 0; | ||
486 | + id3v2->file_owner_licensee.tag_present = 0; | ||
487 | + id3v2->lead_performer_soloist.tag_present = 0; | ||
488 | + id3v2->publisher.tag_present = 0; | ||
489 | + id3v2->private_frame.tag_present = 0; | ||
490 | + id3v2->other_info.tag_present = 0; | ||
491 | + | ||
492 | + /* resetting the flag which indicates that size of the frame has | ||
493 | + * exceeded the max buffer size | ||
494 | + */ | ||
495 | + id3v2->album_movie_show_title.exceeds_buffer_size = 0; | ||
496 | + id3v2->composer_name.exceeds_buffer_size = 0; | ||
497 | + id3v2->content_type.exceeds_buffer_size = 0; | ||
498 | + id3v2->encoded_by.exceeds_buffer_size = 0; | ||
499 | + id3v2->lyricist_text_writer.exceeds_buffer_size = 0; | ||
500 | + id3v2->content_group_description.exceeds_buffer_size = 0; | ||
501 | + id3v2->title_songname_content_description.exceeds_buffer_size = 0; | ||
502 | + id3v2->medxa_type.exceeds_buffer_size = 0; | ||
503 | + id3v2->original_album_movie_show_title.exceeds_buffer_size = 0; | ||
504 | + id3v2->original_filename.exceeds_buffer_size = 0; | ||
505 | + id3v2->original_lyricist_text_writer.exceeds_buffer_size = 0; | ||
506 | + id3v2->original_artist_performer.exceeds_buffer_size = 0; | ||
507 | + id3v2->file_owner_licensee.exceeds_buffer_size = 0; | ||
508 | + id3v2->lead_performer_soloist.exceeds_buffer_size = 0; | ||
509 | + id3v2->publisher.exceeds_buffer_size = 0; | ||
510 | + id3v2->private_frame.exceeds_buffer_size = 0; | ||
511 | + id3v2->other_info.exceeds_buffer_size = 0; | ||
512 | + | ||
513 | + id3v2->bytes_consumed = 0; | ||
514 | + id3v2->header_end = 0; | ||
515 | +} | ||
516 | + | ||
517 | +/*************************************************************** | ||
518 | + * function name : search_id3_v2 | ||
519 | + * | ||
520 | + * description : finds if ID3V2 starts at the start of given buffer. | ||
521 | + * | ||
522 | + * arguments : input parameters | ||
523 | + * buffer input buffer | ||
524 | + * | ||
525 | + * values returned : FLAG 1: ID3 found 0: ID3 not found | ||
526 | + ***************************************************************/ | ||
527 | +WORD32 search_id3_v2(UWORD8 *buffer) | ||
528 | +{ | ||
529 | + UWORD32 temp; | ||
530 | + | ||
531 | + temp = buffer[0] << 16; | ||
532 | + temp |= buffer[1] << 8; | ||
533 | + temp |= buffer[2]; | ||
534 | + | ||
535 | + if (temp == ID3V2) | ||
536 | + return 1; /* ID3 found */ | ||
537 | + | ||
538 | + return 0; /* ID3 not found */ | ||
539 | +} | ||
540 | + | ||
541 | +/************************************************************** | ||
542 | + * function name : search_id3_v1 | ||
543 | + * | ||
544 | + * description : finds if ID3V1 starts at the start of given buffer. | ||
545 | + * | ||
546 | + * arguments : input parameters | ||
547 | + * buffer input buffer | ||
548 | + * | ||
549 | + * values returned : FLAG 1: ID3 found 0: ID3 not found | ||
550 | + **************************************************************/ | ||
551 | +WORD32 search_id3_v1(UWORD8 *buffer) | ||
552 | +{ | ||
553 | + UWORD32 temp; | ||
554 | + | ||
555 | + temp = buffer[0] << 16; | ||
556 | + temp |= buffer[1] << 8; | ||
557 | + temp |= buffer[2]; | ||
558 | + | ||
559 | + if (temp == ID3V1) | ||
560 | + return 1; /* ID3 found */ | ||
561 | + | ||
562 | + return 0; /* ID3 not found */ | ||
563 | +} | ||
564 | + | ||
565 | +/*************************************************************** | ||
566 | + * function name : decode_id3_v1 | ||
567 | + * | ||
568 | + * description : decodes ID3V1 tag. | ||
569 | + * | ||
570 | + * arguments : input parameters | ||
571 | + * buffer input buffer | ||
572 | + * id3v1 structure | ||
573 | + * | ||
574 | + * values returned : bytes consumed | ||
575 | + **************************************************************/ | ||
576 | +WORD32 decode_id3_v1(UWORD8 *buffer, id3v1_struct *id3v1) | ||
577 | +{ | ||
578 | + WORD32 bytes_consumed = 0; | ||
579 | + short tag_type; | ||
580 | + | ||
581 | + /* setting the tag type */ | ||
582 | + tag_type = 1; | ||
583 | + | ||
584 | + bytes_consumed = get_v1_info(buffer, id3v1); | ||
585 | + | ||
586 | + return bytes_consumed; | ||
587 | +} | ||
588 | + | ||
589 | +/*********************************************************** | ||
590 | + * function name : get_v1_info | ||
591 | + * | ||
592 | + * description : gets ID3V1 information fields. | ||
593 | + * | ||
594 | + * arguments : input parameters | ||
595 | + * buffer input buffer | ||
596 | + * id3v1 structure | ||
597 | + * | ||
598 | + * values returned : bytes consumed | ||
599 | + ***********************************************************/ | ||
600 | +WORD32 get_v1_info(UWORD8 *buffer, id3v1_struct *id3v1) | ||
601 | +{ | ||
602 | + WORD32 i; | ||
603 | + WORD32 bytes_consumed = 0; | ||
604 | + | ||
605 | + /* get song_title */ | ||
606 | + for (i = 0; i < 30; i++) | ||
607 | + id3v1->song_title[i] = buffer[i]; | ||
608 | + | ||
609 | + buffer += 30; | ||
610 | + bytes_consumed += 30; | ||
611 | + display1(id3v1->song_title, 30, (WORD8 *)"song_title : "); | ||
612 | + | ||
613 | + /* get artist */ | ||
614 | + for (i = 0; i < 30; i++) | ||
615 | + id3v1->artist[i] = buffer[i]; | ||
616 | + | ||
617 | + buffer += 30; | ||
618 | + bytes_consumed += 30; | ||
619 | + display1(id3v1->artist, 30, (WORD8 *)"artist : "); | ||
620 | + | ||
621 | + /* get album */ | ||
622 | + for (i = 0; i < 30; i++) | ||
623 | + id3v1->album[i] = buffer[i]; | ||
624 | + | ||
625 | + buffer += 30; | ||
626 | + bytes_consumed += 30; | ||
627 | + display1(id3v1->album, 30, (WORD8 *)"album : "); | ||
628 | + | ||
629 | + /* get year */ | ||
630 | + for (i = 0; i < 4; i++) | ||
631 | + id3v1->year[i] = buffer[i]; | ||
632 | + | ||
633 | + buffer += 4; | ||
634 | + bytes_consumed += 4; | ||
635 | + display1(id3v1->year, 4, (WORD8 *)"year : "); | ||
636 | + | ||
637 | + /* get comment */ | ||
638 | + for (i = 0; i < 30; i++) | ||
639 | + id3v1->comment[i] = buffer[i]; | ||
640 | + | ||
641 | + buffer += 30; | ||
642 | + bytes_consumed += 30; | ||
643 | + display1(id3v1->comment, 30, (WORD8 *)"comment : "); | ||
644 | + | ||
645 | + /* get genre */ | ||
646 | + for (i = 0; i < 1; i++) | ||
647 | + id3v1->genre[i] = buffer[i]; | ||
648 | + | ||
649 | + buffer += 1; | ||
650 | + bytes_consumed += 1; | ||
651 | + | ||
652 | + return bytes_consumed; | ||
653 | +} | ||
654 | + | ||
655 | +/***************************************************** | ||
656 | + * function name : decode_id3_v2 | ||
657 | + * | ||
658 | + * description : decodes ID3V2 tag. | ||
659 | + * | ||
660 | + * arguments : input parameters | ||
661 | + * buffer input buffer | ||
662 | + * id3v2 structure | ||
663 | + * continue_flag FLAG to indicate whether | ||
664 | + * it is first call or not | ||
665 | + * insize input buffer size | ||
666 | + * | ||
667 | + * values returned : bytes consumed | ||
668 | + ******************************************************/ | ||
669 | +WORD32 decode_id3_v2(const char *const buffer, | ||
670 | + id3v2_struct *const id3v2, | ||
671 | + WORD32 continue_flag, | ||
672 | + WORD32 insize) | ||
673 | +{ | ||
674 | + UWORD32 size = 0, flag; | ||
675 | + WORD32 i, buf_update_val; | ||
676 | + UWORD8 buf[4], frame_header[10], id3_buffer[10]; | ||
677 | + WORD8 *bitstream_ptr; | ||
678 | + short tag_type; | ||
679 | + | ||
680 | + WORD32 bytes_consumed = 0; | ||
681 | + | ||
682 | + if (id3v2->header_end == 1) { | ||
683 | + id3v2->bytes_consumed += insize; | ||
684 | + if (id3v2->bytes_consumed < id3v2->id3_v2_header.size) | ||
685 | + return 0; | ||
686 | + | ||
687 | + id3v2->bytes_consumed = (id3v2->id3_v2_header.size + 10); | ||
688 | + return 1; | ||
689 | + } | ||
690 | + | ||
691 | + bitstream_ptr = (WORD8 *)id3_buffer; | ||
692 | + | ||
693 | + if (!continue_flag) { | ||
694 | + bytes_consumed += 3; | ||
695 | + /* setting the tag type */ | ||
696 | + tag_type = 2; | ||
697 | + id3v2->id3_v2_header.version = buffer[bytes_consumed + 0] << 8; | ||
698 | + id3v2->id3_v2_header.version |= buffer[bytes_consumed + 1]; | ||
699 | + id3v2->id3_v2_header.flag = buffer[bytes_consumed + 2]; | ||
700 | + | ||
701 | + /* making the msb of each byte zero */ | ||
702 | + buf[0] = buffer[bytes_consumed + 6] & 0x7f; | ||
703 | + buf[1] = buffer[bytes_consumed + 5] & 0x7f; | ||
704 | + buf[2] = buffer[bytes_consumed + 4] & 0x7f; | ||
705 | + buf[3] = buffer[bytes_consumed + 3] & 0x7f; | ||
706 | + | ||
707 | + bytes_consumed += 7; | ||
708 | + | ||
709 | + /* concatenation the bytes after making | ||
710 | + * 7th bit zero to get 28 bits size | ||
711 | + */ | ||
712 | + size = buf[0]; | ||
713 | + size |= (buf[1] << 7); | ||
714 | + size |= (buf[2] << 14); | ||
715 | + size |= (buf[3] << 21); | ||
716 | + /* storing the size */ | ||
717 | + id3v2->id3_v2_header.size = size; | ||
718 | + | ||
719 | + /* check for extended header */ | ||
720 | + if (id3v2->id3_v2_header.flag & 0x20) { | ||
721 | + for (i = 0; i < 10; i++) | ||
722 | + bitstream_ptr[i] = buffer[bytes_consumed + i]; | ||
723 | + | ||
724 | + i = 0; | ||
725 | + bytes_consumed += 10; | ||
726 | + | ||
727 | + size = bitstream_ptr[i++] << 24; | ||
728 | + size |= bitstream_ptr[i++] << 16; | ||
729 | + size |= bitstream_ptr[i++] << 8; | ||
730 | + size |= bitstream_ptr[i++]; | ||
731 | + | ||
732 | + /* two bytes for flag */ | ||
733 | + i += 2; | ||
734 | + { | ||
735 | + UWORD32 padding_size; | ||
736 | + | ||
737 | + padding_size = bitstream_ptr[i++] << 24; | ||
738 | + padding_size |= bitstream_ptr[i++] << 16; | ||
739 | + padding_size |= bitstream_ptr[i++] << 8; | ||
740 | + padding_size |= bitstream_ptr[i++]; | ||
741 | + | ||
742 | + /* skipping the padding and frame size | ||
743 | + * number of bytes | ||
744 | + */ | ||
745 | + bytes_consumed += (padding_size + size); | ||
746 | + } | ||
747 | + } | ||
748 | + } | ||
749 | + | ||
750 | + while (id3v2->header_end != 1) { | ||
751 | + char *key; | ||
752 | + id3_v2_frame_struct *value; | ||
753 | + unsigned int avail_inp; | ||
754 | + | ||
755 | + /* reading the 10 bytes to get the frame header */ | ||
756 | + | ||
757 | + for (i = 0; i < 10; i++) | ||
758 | + frame_header[i] = buffer[bytes_consumed + i]; | ||
759 | + bytes_consumed += 10; | ||
760 | + | ||
761 | + /* getting the size from the header */ | ||
762 | + size = frame_header[4] << 24; | ||
763 | + size |= frame_header[5] << 16; | ||
764 | + size |= frame_header[6] << 8; | ||
765 | + size |= frame_header[7]; | ||
766 | + | ||
767 | + /* decoding the flag, currently not used */ | ||
768 | + flag = frame_header[8] << 8; | ||
769 | + flag |= frame_header[9]; | ||
770 | + | ||
771 | + avail_inp = insize - bytes_consumed; | ||
772 | + | ||
773 | + /* switching to the frame type */ | ||
774 | + switch (CHAR4(frame_header[0], | ||
775 | + frame_header[1], | ||
776 | + frame_header[2], | ||
777 | + frame_header[3])) { | ||
778 | + case CHAR4('A', 'E', 'N', 'C'): | ||
779 | + case CHAR4('A', 'P', 'I', 'C'): | ||
780 | + case CHAR4('C', 'O', 'M', 'M'): | ||
781 | + case CHAR4('C', 'O', 'M', 'R'): | ||
782 | + case CHAR4('E', 'N', 'C', 'R'): | ||
783 | + case CHAR4('E', 'Q', 'U', 'A'): | ||
784 | + case CHAR4('E', 'T', 'C', 'O'): | ||
785 | + case CHAR4('G', 'E', 'O', 'B'): | ||
786 | + case CHAR4('G', 'R', 'I', 'D'): | ||
787 | + case CHAR4('I', 'P', 'L', 'S'): | ||
788 | + case CHAR4('L', 'I', 'N', 'K'): | ||
789 | + case CHAR4('M', 'C', 'D', 'I'): | ||
790 | + case CHAR4('M', 'L', 'L', 'T'): | ||
791 | + case CHAR4('O', 'W', 'N', 'E'): | ||
792 | + case CHAR4('P', 'C', 'N', 'T'): | ||
793 | + case CHAR4('P', 'O', 'P', 'M'): | ||
794 | + case CHAR4('P', 'O', 'S', 'S'): | ||
795 | + case CHAR4('R', 'B', 'U', 'F'): | ||
796 | + case CHAR4('R', 'V', 'A', 'D'): | ||
797 | + case CHAR4('R', 'V', 'R', 'B'): | ||
798 | + case CHAR4('S', 'Y', 'L', 'T'): | ||
799 | + case CHAR4('S', 'Y', 'T', 'C'): | ||
800 | + case CHAR4('T', 'B', 'P', 'M'): | ||
801 | + case CHAR4('T', 'C', 'O', 'P'): | ||
802 | + case CHAR4('T', 'D', 'A', 'T'): | ||
803 | + case CHAR4('T', 'D', 'L', 'Y'): | ||
804 | + case CHAR4('T', 'F', 'L', 'T'): | ||
805 | + case CHAR4('T', 'I', 'M', 'E'): | ||
806 | + case CHAR4('T', 'K', 'E', 'Y'): | ||
807 | + case CHAR4('T', 'L', 'A', 'N'): | ||
808 | + case CHAR4('T', 'L', 'E', 'N'): | ||
809 | + case CHAR4('T', 'M', 'E', 'D'): | ||
810 | + case CHAR4('T', 'O', 'F', 'N'): | ||
811 | + case CHAR4('T', 'O', 'L', 'Y'): | ||
812 | + case CHAR4('T', 'O', 'R', 'Y'): | ||
813 | + case CHAR4('T', 'P', 'E', '2'): | ||
814 | + case CHAR4('T', 'P', 'E', '3'): | ||
815 | + case CHAR4('T', 'P', 'E', '4'): | ||
816 | + case CHAR4('T', 'P', 'O', 'S'): | ||
817 | + case CHAR4('T', 'R', 'C', 'K'): | ||
818 | + case CHAR4('T', 'R', 'D', 'A'): | ||
819 | + case CHAR4('T', 'R', 'S', 'N'): | ||
820 | + case CHAR4('T', 'R', 'S', 'O'): | ||
821 | + case CHAR4('T', 'S', 'I', 'Z'): | ||
822 | + case CHAR4('T', 'S', 'R', 'C'): | ||
823 | + case CHAR4('T', 'S', 'S', 'E'): | ||
824 | + case CHAR4('T', 'Y', 'E', 'R'): | ||
825 | + case CHAR4('T', 'X', 'X', 'X'): | ||
826 | + case CHAR4('U', 'F', 'I', 'D'): | ||
827 | + case CHAR4('U', 'S', 'E', 'R'): | ||
828 | + case CHAR4('U', 'S', 'L', 'T'): | ||
829 | + case CHAR4('W', 'C', 'O', 'M'): | ||
830 | + case CHAR4('W', 'C', 'O', 'P'): | ||
831 | + case CHAR4('W', 'O', 'A', 'F'): | ||
832 | + case CHAR4('W', 'O', 'A', 'R'): | ||
833 | + case CHAR4('W', 'O', 'A', 'S'): | ||
834 | + case CHAR4('W', 'O', 'R', 'S'): | ||
835 | + case CHAR4('W', 'P', 'A', 'Y'): | ||
836 | + case CHAR4('W', 'P', 'U', 'B'): | ||
837 | + case CHAR4('W', 'X', 'X', 'X'): | ||
838 | + case CHAR4('T', 'I', 'T', '3'): | ||
839 | + key = "other_info : "; | ||
840 | + value = &id3v2->other_info; | ||
841 | + break; | ||
842 | + case CHAR4('P', 'R', 'I', 'V'): | ||
843 | + key = "private_frame : "; | ||
844 | + value = &id3v2->private_frame; | ||
845 | + break; | ||
846 | + case CHAR4('T', 'A', 'L', 'B'): | ||
847 | + key = "album_movie_show_title : "; | ||
848 | + value = &id3v2->album_movie_show_title; | ||
849 | + break; | ||
850 | + case CHAR4('T', 'C', 'O', 'M'): | ||
851 | + key = "composer_name : "; | ||
852 | + value = &id3v2->composer_name; | ||
853 | + break; | ||
854 | + case CHAR4('T', 'C', 'O', 'N'): | ||
855 | + key = "content_type : "; | ||
856 | + value = &id3v2->content_type; | ||
857 | + break; | ||
858 | + case CHAR4('T', 'E', 'N', 'C'): | ||
859 | + key = "encoded_by : "; | ||
860 | + value = &id3v2->encoded_by; | ||
861 | + break; | ||
862 | + case CHAR4('T', 'E', 'X', 'T'): | ||
863 | + key = "lyricist_text_writer : "; | ||
864 | + value = &id3v2->lyricist_text_writer; | ||
865 | + break; | ||
866 | + case CHAR4('T', 'I', 'T', '1'): | ||
867 | + key = "content_group_description : "; | ||
868 | + value = &id3v2->content_group_description; | ||
869 | + break; | ||
870 | + case CHAR4('T', 'I', 'T', '2'): | ||
871 | + key = "title_songname_content_description : "; | ||
872 | + value = &id3v2->title_songname_content_description; | ||
873 | + break; | ||
874 | + case CHAR4('T', 'O', 'A', 'L'): | ||
875 | + key = "original_album_movie_show_title : "; | ||
876 | + value = &id3v2->original_album_movie_show_title; | ||
877 | + break; | ||
878 | + case CHAR4('T', 'O', 'P', 'E'): | ||
879 | + key = "original_artist_performer : "; | ||
880 | + value = &id3v2->original_artist_performer; | ||
881 | + break; | ||
882 | + case CHAR4('T', 'O', 'W', 'N'): | ||
883 | + key = "file_owner_licensee : "; | ||
884 | + value = &id3v2->file_owner_licensee; | ||
885 | + break; | ||
886 | + case CHAR4('T', 'P', 'E', '1'): | ||
887 | + key = "lead_performer_soloist : "; | ||
888 | + value = &id3v2->lead_performer_soloist; | ||
889 | + break; | ||
890 | + case CHAR4('T', 'P', 'U', 'B'): | ||
891 | + key = "publisher : "; | ||
892 | + value = &id3v2->publisher; | ||
893 | + break; | ||
894 | + default: | ||
895 | + /* skipping the read 10 bytes */ | ||
896 | + buf_update_val = -10; | ||
897 | + id3v2->header_end = 1; | ||
898 | + value = 0; | ||
899 | + key = 0; | ||
900 | + break; | ||
901 | + } | ||
902 | + | ||
903 | + if (value != 0) | ||
904 | + buf_update_val = get_info(&buffer[bytes_consumed], | ||
905 | + avail_inp, size, value); | ||
906 | + | ||
907 | + /* Negative value for buf_update_val means one of two things: | ||
908 | + * 1. The default case happened and we're done with ID3V2 tag | ||
909 | + * frames, or | ||
910 | + * 2. get_info() returned -1 to indicate that more input is | ||
911 | + * required to decode this frame of the tag. | ||
912 | + */ | ||
913 | + if (buf_update_val >= 0) | ||
914 | + display2(value, | ||
915 | + umin(value->max_size, buf_update_val), key); | ||
916 | + | ||
917 | + if (buf_update_val == -1) { | ||
918 | + id3v2->bytes_consumed += bytes_consumed; | ||
919 | + return 1; | ||
920 | + } | ||
921 | + | ||
922 | + bytes_consumed += buf_update_val; | ||
923 | + | ||
924 | + /* Is there enough input left (10 bytes) to begin | ||
925 | + * decoding another frame? If not, bag out temporarily | ||
926 | + * now. The caller will refill our input buffer and | ||
927 | + * call us again with continue_flag == 1. | ||
928 | + */ | ||
929 | + if (insize - bytes_consumed < 10) { | ||
930 | + id3v2->bytes_consumed += bytes_consumed; | ||
931 | + return 0; /* not completely decoded */ | ||
932 | + } | ||
933 | + } | ||
934 | + | ||
935 | + id3v2->bytes_consumed += bytes_consumed; | ||
936 | + if ((id3v2->bytes_consumed + 10) < id3v2->id3_v2_header.size) | ||
937 | + return 0; /* not completely decoded */ | ||
938 | + | ||
939 | + return 1; /* completely decoded */ | ||
940 | +} | ||
941 | + | ||
942 | +/******************************************************* | ||
943 | + * function name : get_id3_v2_bytes | ||
944 | + * | ||
945 | + * description : tells the size of ID3V2 tag. | ||
946 | + * | ||
947 | + * arguments : input parameters | ||
948 | + * buffer input buffer | ||
949 | + * | ||
950 | + * values returned : bytes consumed | ||
951 | + ********************************************************/ | ||
952 | +WORD32 get_id3_v2_bytes(UWORD8 *buffer) | ||
953 | +{ | ||
954 | + WORD32 size; | ||
955 | + | ||
956 | + /* making the msb of each byte zero */ | ||
957 | + size = (buffer[9] & 0x7f); | ||
958 | + size |= ((buffer[8] & 0x7f) << 7); | ||
959 | + size |= ((buffer[7] & 0x7f) << 14); | ||
960 | + size |= ((buffer[6] & 0x7f) << 21); | ||
961 | + | ||
962 | + return (size + 10); | ||
963 | +} | ||
964 | + | ||
965 | +/**************************************************** | ||
966 | + * function name : get_info | ||
967 | + * | ||
968 | + * description : read the frame information from the input buffer. | ||
969 | + * | ||
970 | + * arguments : input parameters | ||
971 | + * | ||
972 | + * values returned : update value for buffer | ||
973 | + ****************************************************/ | ||
974 | +WORD32 get_info(const char *inp_buffer, | ||
975 | + unsigned int avail_inp, | ||
976 | + WORD32 tag_size, | ||
977 | + id3_v2_frame_struct *dest) | ||
978 | +{ | ||
979 | + WORD32 j; | ||
980 | + | ||
981 | + /* setting the tag to indicate the presence of frame */ | ||
982 | + dest->tag_present = 1; | ||
983 | + /* If there isn't enough input available, we punt back to the top | ||
984 | + * level and ask for more. | ||
985 | + */ | ||
986 | + if (avail_inp < umin(tag_size, dest->max_size)) | ||
987 | + return -1; | ||
988 | + | ||
989 | + if (dest->max_size >= tag_size) { | ||
990 | + for (j = 0; j < tag_size ; j++) | ||
991 | + dest->frame_data[j] = inp_buffer[j]; | ||
992 | + } else { | ||
993 | + dest->exceeds_buffer_size = 1; | ||
994 | + for (j = 0; j < dest->max_size ; j++) | ||
995 | + dest->frame_data[j] = inp_buffer[j]; | ||
996 | + } | ||
997 | + return tag_size; | ||
998 | +} | ||
999 | -- | ||
1000 | 2.7.4 | ||
1001 | |||