Digi
/
meta-digi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
meta-digi/meta-digi-dey/dynamic-layers/freescale-layer/recipes-multimedia/tinycompress/tinycompress/0001-tinycompress-Add-id3-d...

1002 lines
29 KiB
Diff
Executable File
Raw Blame History

From 16f6b7a5baec41f18fde75fd311fb988e3c31810 Mon Sep 17 00:00:00 2001
From: Shengjiu Wang <shengjiu.wang@nxp.com>
Date: Fri, 13 Jul 2018 18:13:24 +0800
Subject: [PATCH] tinycompress: Add id3 decoding
Signed-off-by: Shengjiu Wang <shengjiu.wang@nxp.com>
---
include/tinycompress/id3_tag_decode.h | 198 +++++++++++
src/utils/Makefile.am | 2 +-
src/utils/cplay.c | 88 +++++
src/utils/id3_tag_decode.c | 642 ++++++++++++++++++++++++++++++++++
4 files changed, 929 insertions(+), 1 deletion(-)
create mode 100644 include/tinycompress/id3_tag_decode.h
create mode 100644 src/utils/id3_tag_decode.c
diff --git a/include/tinycompress/id3_tag_decode.h b/include/tinycompress/id3_tag_decode.h
new file mode 100644
index 0000000..1a911d7
--- /dev/null
+++ b/include/tinycompress/id3_tag_decode.h
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2006-2017 Cadence Design Systems, Inc.
+ * Copyright 2018 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/******************************************************************
+ * file name : id3_tag_decode.h
+ *
+ * description : stores typedefs of structures specific to MP3 tag
+ *
+ * revision history:
+ * 29 04 2004 DK creation
+ *****************************************************************/
+
+#ifndef ID3_TAG_DECODE_H
+#define ID3_TAG_DECODE_H
+
+typedef signed char WORD8;
+typedef signed char * pWORD8;
+typedef unsigned char UWORD8;
+typedef unsigned char * pUWORD8;
+
+typedef signed short WORD16;
+typedef signed short * pWORD16;
+typedef unsigned short UWORD16;
+typedef unsigned short * pUWORD16;
+
+typedef signed int WORD24;
+typedef signed int * pWORD24;
+typedef unsigned int UWORD24;
+typedef unsigned int * pUWORD24;
+
+typedef signed int WORD32;
+typedef signed int * pWORD32;
+typedef unsigned int UWORD32;
+typedef unsigned int * pUWORD32;
+
+typedef void VOID;
+typedef void * pVOID;
+
+typedef signed int BOOL;
+typedef unsigned int UBOOL;
+typedef signed int FLAG;
+typedef unsigned int UFLAG;
+typedef signed int LOOPIDX;
+typedef unsigned int ULOOPIDX;
+typedef signed int WORD;
+typedef unsigned int UWORD;
+
+#define MAX_TAG_FRAME_SIZE 100
+
+#define ID3V1 (0x544147) /* 0x544147 is TAG in WORD8 */
+
+#define ID3V2 (0x494433) /* 0x494433 is ID3 in WORD8 */
+
+/*
+ * structure corresponding to ID3 tag v1 header.
+ * this structure has all the field corresponding to ID3 tag v1 header.
+ */
+
+typedef struct {
+ WORD32 tag; // 3 bytes
+
+ WORD16 version; // 2 bytes
+
+ WORD8 flag; //1 byte
+
+ WORD32 size; //4 bytes
+
+} id3_v2_header_struct;
+
+/* structure which will store the frame data and
+ * also put a limit max data to be stored
+ */
+typedef struct {
+ WORD8 frame_data[MAX_TAG_FRAME_SIZE];
+
+ WORD32 max_size; //4 bytes
+
+ WORD16 tag_present;
+
+ WORD16 exceeds_buffer_size;
+
+} id3_v2_frame_struct;
+
+/*
+ * structure corresponding to ID3 tag v2.
+ * this structure has some of the field corresponding to ID3 tag v2.
+ * if user wants to read some more tag information from
+ * the MP3 file, he can add that field in this structure and pass address
+ * of that element to get_inf function in id3_tag_decode.c under the
+ * corresponding field frame header. few fields which are needed are already
+ * populated by reading from the TAG header.
+ */
+typedef struct {
+ id3_v2_frame_struct album_movie_show_title;
+
+ id3_v2_frame_struct composer_name;
+
+ id3_v2_frame_struct content_type;
+
+ id3_v2_frame_struct encoded_by;
+
+ id3_v2_frame_struct lyricist_text_writer;
+
+ id3_v2_frame_struct content_group_description;
+
+ id3_v2_frame_struct title_songname_content_description;
+
+ id3_v2_frame_struct medxa_type;
+
+ id3_v2_frame_struct original_album_movie_show_title;
+
+ id3_v2_frame_struct original_filename;
+
+ id3_v2_frame_struct original_lyricist_text_writer;
+
+ id3_v2_frame_struct original_artist_performer;
+
+ id3_v2_frame_struct file_owner_licensee;
+
+ id3_v2_frame_struct lead_performer_soloist;
+
+ id3_v2_frame_struct publisher;
+
+ id3_v2_frame_struct private_frame;
+
+ id3_v2_frame_struct other_info;
+
+ id3_v2_header_struct id3_v2_header;
+
+ WORD32 header_end;
+
+ WORD32 bytes_consumed;
+
+} id3v2_struct;
+
+/*
+ * structure corresponding to ID3 tag v1.
+ * this structure has all the field corresponding to ID3 tag v1.
+ */
+typedef struct {
+ WORD8 song_title[30]; //30 word8acters
+
+ WORD8 artist[30]; //30 word8acters
+
+ WORD8 album[30]; //30 word8acters
+
+ WORD8 year[4]; //4 word8acters
+
+ WORD8 comment[30]; //30 word8acters
+
+ WORD8 genre[1]; //1 byte
+
+} id3v1_struct;
+
+WORD32 get_info(const char *inp_buffer,
+ unsigned int avail_inp,
+ WORD32 tag_size,
+ id3_v2_frame_struct *dest);
+
+WORD32 search_id3_v2(UWORD8 *buffer);
+
+WORD32 decode_id3_v2(const char *const buffer,
+ id3v2_struct *id3v2,
+ WORD32 continue_flag,
+ WORD32 insize);
+
+WORD32 get_id3_v2_bytes(UWORD8 *buffer);
+
+WORD32 get_v1_info(UWORD8 *buffer, id3v1_struct *id3v1);
+
+WORD32 search_id3_v1(UWORD8 *buffer);
+
+WORD32 decode_id3_v1(UWORD8 *buffer, id3v1_struct *id3v1);
+
+void init_id3v2_field(id3v2_struct *id3v2);
+
+#endif
diff --git a/src/utils/Makefile.am b/src/utils/Makefile.am
index 1b996d4..e813689 100644
--- a/src/utils/Makefile.am
+++ b/src/utils/Makefile.am
@@ -1,6 +1,6 @@
bin_PROGRAMS = cplay crecord
-cplay_SOURCES = cplay.c
+cplay_SOURCES = cplay.c id3_tag_decode.c
crecord_SOURCES = crecord.c
cplay_CFLAGS = -I$(top_srcdir)/include
diff --git a/src/utils/cplay.c b/src/utils/cplay.c
index 87863a3..2a52b52 100644
--- a/src/utils/cplay.c
+++ b/src/utils/cplay.c
@@ -72,6 +72,7 @@
#include "sound/compress_params.h"
#include "tinycompress/tinycompress.h"
#include "tinycompress/tinymp3.h"
+#include "tinycompress/id3_tag_decode.h"
static int verbose;
static const unsigned int DEFAULT_CODEC_ID = SND_AUDIOCODEC_PCM;
@@ -245,12 +246,97 @@ int main(int argc, char **argv)
exit(EXIT_SUCCESS);
}
+void shift_buffer(char *buf, int buf_size, int bytes_consumed)
+{
+ int i;
+
+ if (bytes_consumed <= 0)
+ return;
+
+ for (i = 0; i < buf_size - bytes_consumed; i++)
+ buf[i] = buf[i + bytes_consumed];
+}
+
+void parse_id3(FILE *file, int *offset) {
+ /* ID3 tag specific declarations */
+ unsigned char id3_buf[128];
+ unsigned char id3v2_buf[4096];
+ signed int id3_v1_found = 0, id3_v1_decoded = 0;
+ signed int id3_v2_found = 0, id3_v2_complete = 0;
+ signed int i_bytes_consumed = 0;
+ signed int i_fread_bytes;
+ id3v1_struct id3v1;
+ id3v2_struct id3v2;
+
+ {
+ fseek(file, -128, SEEK_END);
+ fread(id3_buf, 1, 128, file);
+
+ /* search for ID3V1 */
+ id3_v1_found = search_id3_v1(id3_buf + 0);
+ if (id3_v1_found) {
+ /* if ID3V1 is found, decode ID3V1 */
+ decode_id3_v1(id3_buf + 3, &id3v1);
+ id3_v1_decoded = 1;
+ }
+ fseek(file, 0, SEEK_SET);
+ }
+
+ {
+ signed int flag = 0;
+ signed int continue_flag = 0;
+
+ i_fread_bytes = fread(id3v2_buf,
+ sizeof(char), 0x1000, file);
+
+ /* search for ID3V2 */
+ id3_v2_found =
+ search_id3_v2(id3v2_buf);
+
+ if (id3_v2_found) {
+ /* initialise the max fields */
+ init_id3v2_field(&id3v2);
+
+ while (!id3_v2_complete && id3_v2_found) {
+ /* if ID3V2 is found, decode ID3V2 */
+ id3_v2_complete = decode_id3_v2((const char *const)id3v2_buf,
+ &id3v2, continue_flag, i_fread_bytes);
+
+ if (!id3_v2_complete) {
+ continue_flag = 1;
+ i_bytes_consumed = id3v2.bytes_consumed;
+
+ fseek(file, i_bytes_consumed, SEEK_SET);
+
+ i_fread_bytes = fread(id3v2_buf,
+ sizeof(unsigned char), 0x1000, file);
+ if (i_fread_bytes <= 0) {
+ return;
+ }
+ }
+ }
+
+ if (id3_v2_complete) {
+ i_bytes_consumed = id3v2.bytes_consumed;
+ fseek(file, i_bytes_consumed, SEEK_SET);
+ }
+ }
+ }
+
+ *offset = i_bytes_consumed;
+}
+
void get_codec_mp3(FILE *file, struct compr_config *config,
struct snd_codec *codec)
{
size_t read;
struct mp3_header header;
unsigned int channels, rate, bits;
+ int offset = 0;
+
+ parse_id3(file, &offset);
+
+ fseek(file, offset, SEEK_SET);
read = fread(&header, 1, sizeof(header), file);
if (read != sizeof(header)) {
@@ -279,6 +365,8 @@ void get_codec_mp3(FILE *file, struct compr_config *config,
codec->level = 0;
codec->ch_mode = 0;
codec->format = 0;
+
+ fseek(file, offset, SEEK_SET);
}
void get_codec_iec(FILE *file, struct compr_config *config,
diff --git a/src/utils/id3_tag_decode.c b/src/utils/id3_tag_decode.c
new file mode 100644
index 0000000..393967a
--- /dev/null
+++ b/src/utils/id3_tag_decode.c
@@ -0,0 +1,642 @@
+/*
+ * Copyright (c) 2006-2017 Cadence Design Systems, Inc.
+ * Copyright 2018 NXP
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include <ctype.h>
+#include "tinycompress/id3_tag_decode.h"
+
+#define CHAR4(c1, c2, c3, c4) \
+ (int)(((unsigned char)(c1) << 24) | \
+ ((unsigned char)(c2) << 16) | \
+ ((unsigned char)(c3) << 8) | \
+ ((unsigned char)c4))
+
+#ifndef MSVC_BUILD
+unsigned int umin(unsigned int a, unsigned int b)
+{
+ return (a < b ? a : b);
+}
+
+#else
+unsigned int umin(unsigned int a, unsigned int b)
+{
+ return (a < b ? a : b);
+}
+#endif
+
+/***********************************************************
+ * function name : display
+ *
+ * description : display ID3 tag contents.
+ *
+ * arguments : input parameters
+ *
+ * values returned : 0
+ ***********************************************************/
+
+static void display2(const id3_v2_frame_struct * const src,
+ int size,
+ const char * const disp)
+{
+ int j;
+
+
+ for (j = 0; j < size; j++) {
+ int c = src->frame_data[j];
+
+ if (c) {
+ if (!isprint(c))
+ break;
+ }
+ }
+}
+
+static VOID display1(WORD8 src[], WORD32 size, WORD8 disp[])
+{
+ WORD32 j;
+
+ for (j = 0; j < size ; j++) {
+ int c = src[j];
+
+ if (c) {
+ if (!isprint(c))
+ break;
+ }
+ }
+}
+
+/*****************************************************************
+ * function name : init_id3_header
+ *
+ * description : initialise the max filed size of teh farem.
+ *
+ * arguments : input parameters
+ *
+ * values returned : 0
+ ****************************************************************/
+
+VOID init_id3v2_field(id3v2_struct *id3v2)
+{
+ id3v2->album_movie_show_title.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->composer_name.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->content_type.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->encoded_by.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->lyricist_text_writer.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->content_group_description.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->title_songname_content_description.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->medxa_type.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->original_album_movie_show_title.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->original_filename.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->original_lyricist_text_writer.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->original_artist_performer.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->file_owner_licensee.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->lead_performer_soloist.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->publisher.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->private_frame.max_size = MAX_TAG_FRAME_SIZE;
+ id3v2->other_info.max_size = MAX_TAG_FRAME_SIZE;
+
+ /* resetting the flag to indicate presese of frame */
+ id3v2->album_movie_show_title.tag_present = 0;
+ id3v2->composer_name.tag_present = 0;
+ id3v2->content_type.tag_present = 0;
+ id3v2->encoded_by.tag_present = 0;
+ id3v2->lyricist_text_writer.tag_present = 0;
+ id3v2->content_group_description.tag_present = 0;
+ id3v2->title_songname_content_description.tag_present = 0;
+ id3v2->medxa_type.tag_present = 0;
+ id3v2->original_album_movie_show_title.tag_present = 0;
+ id3v2->original_filename.tag_present = 0;
+ id3v2->original_lyricist_text_writer.tag_present = 0;
+ id3v2->original_artist_performer.tag_present = 0;
+ id3v2->file_owner_licensee.tag_present = 0;
+ id3v2->lead_performer_soloist.tag_present = 0;
+ id3v2->publisher.tag_present = 0;
+ id3v2->private_frame.tag_present = 0;
+ id3v2->other_info.tag_present = 0;
+
+ /* resetting the flag which indicates that size of the frame has
+ * exceeded the max buffer size
+ */
+ id3v2->album_movie_show_title.exceeds_buffer_size = 0;
+ id3v2->composer_name.exceeds_buffer_size = 0;
+ id3v2->content_type.exceeds_buffer_size = 0;
+ id3v2->encoded_by.exceeds_buffer_size = 0;
+ id3v2->lyricist_text_writer.exceeds_buffer_size = 0;
+ id3v2->content_group_description.exceeds_buffer_size = 0;
+ id3v2->title_songname_content_description.exceeds_buffer_size = 0;
+ id3v2->medxa_type.exceeds_buffer_size = 0;
+ id3v2->original_album_movie_show_title.exceeds_buffer_size = 0;
+ id3v2->original_filename.exceeds_buffer_size = 0;
+ id3v2->original_lyricist_text_writer.exceeds_buffer_size = 0;
+ id3v2->original_artist_performer.exceeds_buffer_size = 0;
+ id3v2->file_owner_licensee.exceeds_buffer_size = 0;
+ id3v2->lead_performer_soloist.exceeds_buffer_size = 0;
+ id3v2->publisher.exceeds_buffer_size = 0;
+ id3v2->private_frame.exceeds_buffer_size = 0;
+ id3v2->other_info.exceeds_buffer_size = 0;
+
+ id3v2->bytes_consumed = 0;
+ id3v2->header_end = 0;
+}
+
+/***************************************************************
+ * function name : search_id3_v2
+ *
+ * description : finds if ID3V2 starts at the start of given buffer.
+ *
+ * arguments : input parameters
+ * buffer input buffer
+ *
+ * values returned : FLAG 1: ID3 found 0: ID3 not found
+ ***************************************************************/
+WORD32 search_id3_v2(UWORD8 *buffer)
+{
+ UWORD32 temp;
+
+ temp = buffer[0] << 16;
+ temp |= buffer[1] << 8;
+ temp |= buffer[2];
+
+ if (temp == ID3V2)
+ return 1; /* ID3 found */
+
+ return 0; /* ID3 not found */
+}
+
+/**************************************************************
+ * function name : search_id3_v1
+ *
+ * description : finds if ID3V1 starts at the start of given buffer.
+ *
+ * arguments : input parameters
+ * buffer input buffer
+ *
+ * values returned : FLAG 1: ID3 found 0: ID3 not found
+ **************************************************************/
+WORD32 search_id3_v1(UWORD8 *buffer)
+{
+ UWORD32 temp;
+
+ temp = buffer[0] << 16;
+ temp |= buffer[1] << 8;
+ temp |= buffer[2];
+
+ if (temp == ID3V1)
+ return 1; /* ID3 found */
+
+ return 0; /* ID3 not found */
+}
+
+/***************************************************************
+ * function name : decode_id3_v1
+ *
+ * description : decodes ID3V1 tag.
+ *
+ * arguments : input parameters
+ * buffer input buffer
+ * id3v1 structure
+ *
+ * values returned : bytes consumed
+ **************************************************************/
+WORD32 decode_id3_v1(UWORD8 *buffer, id3v1_struct *id3v1)
+{
+ WORD32 bytes_consumed = 0;
+ short tag_type;
+
+ /* setting the tag type */
+ tag_type = 1;
+
+ bytes_consumed = get_v1_info(buffer, id3v1);
+
+ return bytes_consumed;
+}
+
+/***********************************************************
+ * function name : get_v1_info
+ *
+ * description : gets ID3V1 information fields.
+ *
+ * arguments : input parameters
+ * buffer input buffer
+ * id3v1 structure
+ *
+ * values returned : bytes consumed
+ ***********************************************************/
+WORD32 get_v1_info(UWORD8 *buffer, id3v1_struct *id3v1)
+{
+ WORD32 i;
+ WORD32 bytes_consumed = 0;
+
+ /* get song_title */
+ for (i = 0; i < 30; i++)
+ id3v1->song_title[i] = buffer[i];
+
+ buffer += 30;
+ bytes_consumed += 30;
+ display1(id3v1->song_title, 30, (WORD8 *)"song_title : ");
+
+ /* get artist */
+ for (i = 0; i < 30; i++)
+ id3v1->artist[i] = buffer[i];
+
+ buffer += 30;
+ bytes_consumed += 30;
+ display1(id3v1->artist, 30, (WORD8 *)"artist : ");
+
+ /* get album */
+ for (i = 0; i < 30; i++)
+ id3v1->album[i] = buffer[i];
+
+ buffer += 30;
+ bytes_consumed += 30;
+ display1(id3v1->album, 30, (WORD8 *)"album : ");
+
+ /* get year */
+ for (i = 0; i < 4; i++)
+ id3v1->year[i] = buffer[i];
+
+ buffer += 4;
+ bytes_consumed += 4;
+ display1(id3v1->year, 4, (WORD8 *)"year : ");
+
+ /* get comment */
+ for (i = 0; i < 30; i++)
+ id3v1->comment[i] = buffer[i];
+
+ buffer += 30;
+ bytes_consumed += 30;
+ display1(id3v1->comment, 30, (WORD8 *)"comment : ");
+
+ /* get genre */
+ for (i = 0; i < 1; i++)
+ id3v1->genre[i] = buffer[i];
+
+ buffer += 1;
+ bytes_consumed += 1;
+
+ return bytes_consumed;
+}
+
+/*****************************************************
+ * function name : decode_id3_v2
+ *
+ * description : decodes ID3V2 tag.
+ *
+ * arguments : input parameters
+ * buffer input buffer
+ * id3v2 structure
+ * continue_flag FLAG to indicate whether
+ * it is first call or not
+ * insize input buffer size
+ *
+ * values returned : bytes consumed
+ ******************************************************/
+WORD32 decode_id3_v2(const char *const buffer,
+ id3v2_struct *const id3v2,
+ WORD32 continue_flag,
+ WORD32 insize)
+{
+ UWORD32 size = 0, flag;
+ WORD32 i, buf_update_val;
+ UWORD8 buf[4], frame_header[10], id3_buffer[10];
+ WORD8 *bitstream_ptr;
+ short tag_type;
+
+ WORD32 bytes_consumed = 0;
+
+ if (id3v2->header_end == 1) {
+ id3v2->bytes_consumed += insize;
+ if (id3v2->bytes_consumed < id3v2->id3_v2_header.size)
+ return 0;
+
+ id3v2->bytes_consumed = (id3v2->id3_v2_header.size + 10);
+ return 1;
+ }
+
+ bitstream_ptr = (WORD8 *)id3_buffer;
+
+ if (!continue_flag) {
+ bytes_consumed += 3;
+ /* setting the tag type */
+ tag_type = 2;
+ id3v2->id3_v2_header.version = buffer[bytes_consumed + 0] << 8;
+ id3v2->id3_v2_header.version |= buffer[bytes_consumed + 1];
+ id3v2->id3_v2_header.flag = buffer[bytes_consumed + 2];
+
+ /* making the msb of each byte zero */
+ buf[0] = buffer[bytes_consumed + 6] & 0x7f;
+ buf[1] = buffer[bytes_consumed + 5] & 0x7f;
+ buf[2] = buffer[bytes_consumed + 4] & 0x7f;
+ buf[3] = buffer[bytes_consumed + 3] & 0x7f;
+
+ bytes_consumed += 7;
+
+ /* concatenation the bytes after making
+ * 7th bit zero to get 28 bits size
+ */
+ size = buf[0];
+ size |= (buf[1] << 7);
+ size |= (buf[2] << 14);
+ size |= (buf[3] << 21);
+ /* storing the size */
+ id3v2->id3_v2_header.size = size;
+
+ /* check for extended header */
+ if (id3v2->id3_v2_header.flag & 0x20) {
+ for (i = 0; i < 10; i++)
+ bitstream_ptr[i] = buffer[bytes_consumed + i];
+
+ i = 0;
+ bytes_consumed += 10;
+
+ size = bitstream_ptr[i++] << 24;
+ size |= bitstream_ptr[i++] << 16;
+ size |= bitstream_ptr[i++] << 8;
+ size |= bitstream_ptr[i++];
+
+ /* two bytes for flag */
+ i += 2;
+ {
+ UWORD32 padding_size;
+
+ padding_size = bitstream_ptr[i++] << 24;
+ padding_size |= bitstream_ptr[i++] << 16;
+ padding_size |= bitstream_ptr[i++] << 8;
+ padding_size |= bitstream_ptr[i++];
+
+ /* skipping the padding and frame size
+ * number of bytes
+ */
+ bytes_consumed += (padding_size + size);
+ }
+ }
+ }
+
+ while (id3v2->header_end != 1) {
+ char *key;
+ id3_v2_frame_struct *value;
+ unsigned int avail_inp;
+
+ /* reading the 10 bytes to get the frame header */
+
+ for (i = 0; i < 10; i++)
+ frame_header[i] = buffer[bytes_consumed + i];
+ bytes_consumed += 10;
+
+ /* getting the size from the header */
+ size = frame_header[4] << 24;
+ size |= frame_header[5] << 16;
+ size |= frame_header[6] << 8;
+ size |= frame_header[7];
+
+ /* decoding the flag, currently not used */
+ flag = frame_header[8] << 8;
+ flag |= frame_header[9];
+
+ avail_inp = insize - bytes_consumed;
+
+ /* switching to the frame type */
+ switch (CHAR4(frame_header[0],
+ frame_header[1],
+ frame_header[2],
+ frame_header[3])) {
+ case CHAR4('A', 'E', 'N', 'C'):
+ case CHAR4('A', 'P', 'I', 'C'):
+ case CHAR4('C', 'O', 'M', 'M'):
+ case CHAR4('C', 'O', 'M', 'R'):
+ case CHAR4('E', 'N', 'C', 'R'):
+ case CHAR4('E', 'Q', 'U', 'A'):
+ case CHAR4('E', 'T', 'C', 'O'):
+ case CHAR4('G', 'E', 'O', 'B'):
+ case CHAR4('G', 'R', 'I', 'D'):
+ case CHAR4('I', 'P', 'L', 'S'):
+ case CHAR4('L', 'I', 'N', 'K'):
+ case CHAR4('M', 'C', 'D', 'I'):
+ case CHAR4('M', 'L', 'L', 'T'):
+ case CHAR4('O', 'W', 'N', 'E'):
+ case CHAR4('P', 'C', 'N', 'T'):
+ case CHAR4('P', 'O', 'P', 'M'):
+ case CHAR4('P', 'O', 'S', 'S'):
+ case CHAR4('R', 'B', 'U', 'F'):
+ case CHAR4('R', 'V', 'A', 'D'):
+ case CHAR4('R', 'V', 'R', 'B'):
+ case CHAR4('S', 'Y', 'L', 'T'):
+ case CHAR4('S', 'Y', 'T', 'C'):
+ case CHAR4('T', 'B', 'P', 'M'):
+ case CHAR4('T', 'C', 'O', 'P'):
+ case CHAR4('T', 'D', 'A', 'T'):
+ case CHAR4('T', 'D', 'L', 'Y'):
+ case CHAR4('T', 'F', 'L', 'T'):
+ case CHAR4('T', 'I', 'M', 'E'):
+ case CHAR4('T', 'K', 'E', 'Y'):
+ case CHAR4('T', 'L', 'A', 'N'):
+ case CHAR4('T', 'L', 'E', 'N'):
+ case CHAR4('T', 'M', 'E', 'D'):
+ case CHAR4('T', 'O', 'F', 'N'):
+ case CHAR4('T', 'O', 'L', 'Y'):
+ case CHAR4('T', 'O', 'R', 'Y'):
+ case CHAR4('T', 'P', 'E', '2'):
+ case CHAR4('T', 'P', 'E', '3'):
+ case CHAR4('T', 'P', 'E', '4'):
+ case CHAR4('T', 'P', 'O', 'S'):
+ case CHAR4('T', 'R', 'C', 'K'):
+ case CHAR4('T', 'R', 'D', 'A'):
+ case CHAR4('T', 'R', 'S', 'N'):
+ case CHAR4('T', 'R', 'S', 'O'):
+ case CHAR4('T', 'S', 'I', 'Z'):
+ case CHAR4('T', 'S', 'R', 'C'):
+ case CHAR4('T', 'S', 'S', 'E'):
+ case CHAR4('T', 'Y', 'E', 'R'):
+ case CHAR4('T', 'X', 'X', 'X'):
+ case CHAR4('U', 'F', 'I', 'D'):
+ case CHAR4('U', 'S', 'E', 'R'):
+ case CHAR4('U', 'S', 'L', 'T'):
+ case CHAR4('W', 'C', 'O', 'M'):
+ case CHAR4('W', 'C', 'O', 'P'):
+ case CHAR4('W', 'O', 'A', 'F'):
+ case CHAR4('W', 'O', 'A', 'R'):
+ case CHAR4('W', 'O', 'A', 'S'):
+ case CHAR4('W', 'O', 'R', 'S'):
+ case CHAR4('W', 'P', 'A', 'Y'):
+ case CHAR4('W', 'P', 'U', 'B'):
+ case CHAR4('W', 'X', 'X', 'X'):
+ case CHAR4('T', 'I', 'T', '3'):
+ key = "other_info : ";
+ value = &id3v2->other_info;
+ break;
+ case CHAR4('P', 'R', 'I', 'V'):
+ key = "private_frame : ";
+ value = &id3v2->private_frame;
+ break;
+ case CHAR4('T', 'A', 'L', 'B'):
+ key = "album_movie_show_title : ";
+ value = &id3v2->album_movie_show_title;
+ break;
+ case CHAR4('T', 'C', 'O', 'M'):
+ key = "composer_name : ";
+ value = &id3v2->composer_name;
+ break;
+ case CHAR4('T', 'C', 'O', 'N'):
+ key = "content_type : ";
+ value = &id3v2->content_type;
+ break;
+ case CHAR4('T', 'E', 'N', 'C'):
+ key = "encoded_by : ";
+ value = &id3v2->encoded_by;
+ break;
+ case CHAR4('T', 'E', 'X', 'T'):
+ key = "lyricist_text_writer : ";
+ value = &id3v2->lyricist_text_writer;
+ break;
+ case CHAR4('T', 'I', 'T', '1'):
+ key = "content_group_description : ";
+ value = &id3v2->content_group_description;
+ break;
+ case CHAR4('T', 'I', 'T', '2'):
+ key = "title_songname_content_description : ";
+ value = &id3v2->title_songname_content_description;
+ break;
+ case CHAR4('T', 'O', 'A', 'L'):
+ key = "original_album_movie_show_title : ";
+ value = &id3v2->original_album_movie_show_title;
+ break;
+ case CHAR4('T', 'O', 'P', 'E'):
+ key = "original_artist_performer : ";
+ value = &id3v2->original_artist_performer;
+ break;
+ case CHAR4('T', 'O', 'W', 'N'):
+ key = "file_owner_licensee : ";
+ value = &id3v2->file_owner_licensee;
+ break;
+ case CHAR4('T', 'P', 'E', '1'):
+ key = "lead_performer_soloist : ";
+ value = &id3v2->lead_performer_soloist;
+ break;
+ case CHAR4('T', 'P', 'U', 'B'):
+ key = "publisher : ";
+ value = &id3v2->publisher;
+ break;
+ default:
+ /* skipping the read 10 bytes */
+ buf_update_val = -10;
+ id3v2->header_end = 1;
+ value = 0;
+ key = 0;
+ break;
+ }
+
+ if (value != 0)
+ buf_update_val = get_info(&buffer[bytes_consumed],
+ avail_inp, size, value);
+
+ /* Negative value for buf_update_val means one of two things:
+ * 1. The default case happened and we're done with ID3V2 tag
+ * frames, or
+ * 2. get_info() returned -1 to indicate that more input is
+ * required to decode this frame of the tag.
+ */
+ if (buf_update_val >= 0)
+ display2(value,
+ umin(value->max_size, buf_update_val), key);
+
+ if (buf_update_val == -1) {
+ id3v2->bytes_consumed += bytes_consumed;
+ return 1;
+ }
+
+ bytes_consumed += buf_update_val;
+
+ /* Is there enough input left (10 bytes) to begin
+ * decoding another frame? If not, bag out temporarily
+ * now. The caller will refill our input buffer and
+ * call us again with continue_flag == 1.
+ */
+ if (insize - bytes_consumed < 10) {
+ id3v2->bytes_consumed += bytes_consumed;
+ return 0; /* not completely decoded */
+ }
+ }
+
+ id3v2->bytes_consumed += bytes_consumed;
+ if ((id3v2->bytes_consumed + 10) < id3v2->id3_v2_header.size)
+ return 0; /* not completely decoded */
+
+ return 1; /* completely decoded */
+}
+
+/*******************************************************
+ * function name : get_id3_v2_bytes
+ *
+ * description : tells the size of ID3V2 tag.
+ *
+ * arguments : input parameters
+ * buffer input buffer
+ *
+ * values returned : bytes consumed
+ ********************************************************/
+WORD32 get_id3_v2_bytes(UWORD8 *buffer)
+{
+ WORD32 size;
+
+ /* making the msb of each byte zero */
+ size = (buffer[9] & 0x7f);
+ size |= ((buffer[8] & 0x7f) << 7);
+ size |= ((buffer[7] & 0x7f) << 14);
+ size |= ((buffer[6] & 0x7f) << 21);
+
+ return (size + 10);
+}
+
+/****************************************************
+ * function name : get_info
+ *
+ * description : read the frame information from the input buffer.
+ *
+ * arguments : input parameters
+ *
+ * values returned : update value for buffer
+ ****************************************************/
+WORD32 get_info(const char *inp_buffer,
+ unsigned int avail_inp,
+ WORD32 tag_size,
+ id3_v2_frame_struct *dest)
+{
+ WORD32 j;
+
+ /* setting the tag to indicate the presence of frame */
+ dest->tag_present = 1;
+ /* If there isn't enough input available, we punt back to the top
+ * level and ask for more.
+ */
+ if (avail_inp < umin(tag_size, dest->max_size))
+ return -1;
+
+ if (dest->max_size >= tag_size) {
+ for (j = 0; j < tag_size ; j++)
+ dest->frame_data[j] = inp_buffer[j];
+ } else {
+ dest->exceeds_buffer_size = 1;
+ for (j = 0; j < dest->max_size ; j++)
+ dest->frame_data[j] = inp_buffer[j];
+ }
+ return tag_size;
+}
--
2.7.4
Reference in New Issue View Git Blame Copy Permalink