import mp4ff, since its not installed correctly by faad2
git-svn-id: https://svn.musicpd.org/mpd/trunk@265 09075e82-0dd4-0310-85a5-a0d7c8717e4f
This commit is contained in:
Warren Dukes
parent
f114fbd437
commit
bf769906f3
5
README
5
README
|
|
@ -9,8 +9,11 @@ retrieval, and playlist management can all be managed remotely.
|
|||
|
||||
To install MPD, see INSTALL.
|
||||
|
||||
MPD includes 2 libraries in the source. libid3tag and libmad are released under
|
||||
MPD includes 3 libraries in the source. libid3tag and libmad are released under
|
||||
the GPL and copyrighted by Robert Leslie (http://www.underbit.com/products/mad).
|
||||
mp4ff is released under the GPL and copyrighted by M. Bakker, Ahead Software AG
|
||||
(http://www.nero.com) and is distributed as a part of the FAAD2 - Freeware
|
||||
Advance Audio (AAC) Decoder.
|
||||
|
||||
MPD is released under the GNU Public License.
|
||||
You should have received a copy of the GNU General Public License
|
||||
|
|
|
|||
25
configure.ac
25
configure.ac
|
|
@ -17,6 +17,8 @@ AC_SUBST(MAD_SUBDIR)
|
|||
AC_SUBST(MAD_LIB)
|
||||
AC_SUBST(ID3_SUBDIR)
|
||||
AC_SUBST(ID3_LIB)
|
||||
AC_SUBST(MP4FF_SUBDIR)
|
||||
AC_SUBST(MP4FF_LIB)
|
||||
AC_SUBST(MPD_LIBS)
|
||||
AC_SUBST(MPD_CFLAGS)
|
||||
|
||||
|
|
@ -42,9 +44,9 @@ AC_ARG_WITH(mad,[ --with-mad=PFX Prefix where libmad is installed (optional)]
|
|||
AC_ARG_WITH(mad-libraries,[ --with-mad-libraries=DIR Directory where libmad library is installed (optional)], mad_libraries="$withval", mad_libraries="")
|
||||
AC_ARG_WITH(mad-includes,[ --with-mad-includes=DIR Directory where mad header files are installed (optional)], mad_includes="$withval", mad_includes="")
|
||||
|
||||
AC_ARG_WITH(faad,[ --with-faad=PFX Prefix where faad lib is installed (optional)], faad_prefix="$withval", faad_prefix="")
|
||||
AC_ARG_WITH(faad-libraries,[ --with-faad-libraries=DIR Directory where faad library is installed (optional)], faad_libraries="$withval", faad_libraries="")
|
||||
AC_ARG_WITH(faad-includes,[ --with-faad-includes=DIR Directory where faad header files are installed (optional)], faad_includes="$withval", faad_includes="")
|
||||
AC_ARG_WITH(faad2,[ --with-faad2=PFX Prefix where faad2 is installed (optional)], faad_prefix="$withval", faad_prefix="")
|
||||
AC_ARG_WITH(faad2-libraries,[ --with-faad-libraries=DIR Directory where faad2 library is installed (optional)], faad_libraries="$withval", faad_libraries="")
|
||||
AC_ARG_WITH(faad2-includes,[ --with-faad-includes=DIR Directory where faad2 header files are installed (optional)], faad_includes="$withval", faad_includes="")
|
||||
|
||||
AC_C_BIGENDIAN
|
||||
|
||||
|
|
@ -195,6 +197,8 @@ if test x$enable_mp3 = xyes; then
|
|||
MPD_CFLAGS="$MPD_CFLAGS -DHAVE_MAD"
|
||||
fi
|
||||
|
||||
MP4FF_SUBDIR=""
|
||||
|
||||
if test x$enable_aac = xyes; then
|
||||
if test "x$faad_libraries" != "x" ; then
|
||||
FAAD_LIBS="-L$faad_libraries"
|
||||
|
|
@ -204,7 +208,7 @@ if test x$enable_aac = xyes; then
|
|||
FAAD_LIBS="-L$libdir"
|
||||
fi
|
||||
|
||||
FAAD_LIBS="$FAAD_LIBS -lfaad"
|
||||
FAAD_LIBS="$FAAD_LIBS -lfaad -lmp4v2"
|
||||
|
||||
if test "x$faad_includes" != "x" ; then
|
||||
FAAD_CFLAGS="-I$faad_includes"
|
||||
|
|
@ -220,7 +224,16 @@ if test x$enable_aac = xyes; then
|
|||
LIBS="$LIBS $MPD_LIBS $FAAD_LIBS"
|
||||
AC_CHECK_HEADER(faad.h,,enable_aac=no)
|
||||
if test x$enable_aac = xyes; then
|
||||
AC_CHECK_LIB(faad, faacDecDecode,[MPD_LIBS="$MPD_LIBS $FAAD_LIBS";MPD_CFLAGS="$MPD_CFLAGS $FAAD_CFLAGS -DHAVE_FAAD"],enable_aac=no)
|
||||
AC_CHECK_HEADER(mp4.h,,enable_aac=no)
|
||||
fi
|
||||
if test x$enable_aac = xyes; then
|
||||
AC_CHECK_LIB(mp4v2, MP4Create,,enable_aac=no)
|
||||
fi
|
||||
if test x$enable_aac = xyes; then
|
||||
AC_CHECK_LIB(mp4v2, MP4MetadataDelete,,enable_aac=no)
|
||||
fi
|
||||
if test x$enable_aac = xyes; then
|
||||
AC_CHECK_LIB(faad, faacDecDecode,[MPD_LIBS="$MPD_LIBS $FAAD_LIBS";MPD_CFLAGS="$MPD_CFLAGS $FAAD_CFLAGS -DHAVE_FAAD";MP4FF_SUBDIR="mp4ff";MP4FF_LIB="mp4ff/libmp4ff.la"],enable_aac=no)
|
||||
fi
|
||||
CFLAGS=$oldcflags
|
||||
LIBS=$oldlibs
|
||||
|
|
@ -320,4 +333,4 @@ if test x$enable_audiofile = xyes; then
|
|||
[enable_audiofile=no;AC_MSG_WARN(You need audiofile -- disabling audiofile support)])
|
||||
fi
|
||||
|
||||
AC_OUTPUT(doc/Makefile src/Makefile Makefile )
|
||||
AC_OUTPUT(src/mp4ff/Makefile doc/Makefile src/Makefile Makefile )
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
bin_PROGRAMS = mpd
|
||||
SUBDIRS = $(ID3_SUBDIR) $(MAD_SUBDIR)
|
||||
SUBDIRS = $(ID3_SUBDIR) $(MAD_SUBDIR) $(MP4FF_SUBDIR)
|
||||
mpd_headers = buffer2array.h interface.h command.h playlist.h ls.h \
|
||||
song.h list.h directory.h tables.h utils.h path.h mp3_decode.h \
|
||||
tag.h player.h listen.h conf.h ogg_decode.h volume.h flac_decode.h \
|
||||
|
|
@ -12,4 +12,4 @@ mpd_SOURCES = main.c buffer2array.c interface.c command.c playlist.c ls.c \
|
|||
audiofile_decode.c charConv.c permission.c pcm_utils.c $(mpd_headers)
|
||||
|
||||
mpd_CFLAGS = $(MPD_CFLAGS)
|
||||
mpd_LDADD = $(MPD_LIBS) $(ID3_LIB) $(MAD_LIB)
|
||||
mpd_LDADD = $(MPD_LIBS) $(ID3_LIB) $(MAD_LIB) $(MP4FF_LIB)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,7 @@
|
|||
noinst_LTLIBRARIES = libmp4ff.la
|
||||
|
||||
noinst_HEADERS = mp4ff.h
|
||||
|
||||
libmp4ff_la_SOURCES = mp4ff.c mp4atom.c mp4meta.c mp4sample.c mp4util.c \
|
||||
mp4tagupdate.c mp4ff.h mp4ffint.h mp4ff_int_types.h \
|
||||
drms.h drms.c drmstables.h
|
||||
|
|
@ -0,0 +1,373 @@
|
|||
# Makefile.in generated by automake 1.6.3 from Makefile.am.
|
||||
# @configure_input@
|
||||
|
||||
# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
|
||||
# Free Software Foundation, Inc.
|
||||
# This Makefile.in is free software; the Free Software Foundation
|
||||
# gives unlimited permission to copy and/or distribute it,
|
||||
# with or without modifications, as long as this notice is preserved.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
|
||||
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
||||
# PARTICULAR PURPOSE.
|
||||
|
||||
@SET_MAKE@
|
||||
SHELL = @SHELL@
|
||||
|
||||
srcdir = @srcdir@
|
||||
top_srcdir = @top_srcdir@
|
||||
VPATH = @srcdir@
|
||||
prefix = @prefix@
|
||||
exec_prefix = @exec_prefix@
|
||||
|
||||
bindir = @bindir@
|
||||
sbindir = @sbindir@
|
||||
libexecdir = @libexecdir@
|
||||
datadir = @datadir@
|
||||
sysconfdir = @sysconfdir@
|
||||
sharedstatedir = @sharedstatedir@
|
||||
localstatedir = @localstatedir@
|
||||
libdir = @libdir@
|
||||
infodir = @infodir@
|
||||
mandir = @mandir@
|
||||
includedir = @includedir@
|
||||
oldincludedir = /usr/include
|
||||
pkgdatadir = $(datadir)/@PACKAGE@
|
||||
pkglibdir = $(libdir)/@PACKAGE@
|
||||
pkgincludedir = $(includedir)/@PACKAGE@
|
||||
top_builddir = ../..
|
||||
|
||||
ACLOCAL = @ACLOCAL@
|
||||
AUTOCONF = @AUTOCONF@
|
||||
AUTOMAKE = @AUTOMAKE@
|
||||
AUTOHEADER = @AUTOHEADER@
|
||||
|
||||
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_PROGRAM = @INSTALL_PROGRAM@
|
||||
INSTALL_DATA = @INSTALL_DATA@
|
||||
install_sh_DATA = $(install_sh) -c -m 644
|
||||
install_sh_PROGRAM = $(install_sh) -c
|
||||
install_sh_SCRIPT = $(install_sh) -c
|
||||
INSTALL_SCRIPT = @INSTALL_SCRIPT@
|
||||
INSTALL_HEADER = $(INSTALL_DATA)
|
||||
transform = @program_transform_name@
|
||||
NORMAL_INSTALL = :
|
||||
PRE_INSTALL = :
|
||||
POST_INSTALL = :
|
||||
NORMAL_UNINSTALL = :
|
||||
PRE_UNINSTALL = :
|
||||
POST_UNINSTALL = :
|
||||
host_alias = @host_alias@
|
||||
host_triplet = @host@
|
||||
|
||||
EXEEXT = @EXEEXT@
|
||||
OBJEXT = @OBJEXT@
|
||||
PATH_SEPARATOR = @PATH_SEPARATOR@
|
||||
AMTAR = @AMTAR@
|
||||
AO_CFLAGS = @AO_CFLAGS@
|
||||
AO_LIBS = @AO_LIBS@
|
||||
AR = @AR@
|
||||
AS = @AS@
|
||||
AUDIOFILE_CFLAGS = @AUDIOFILE_CFLAGS@
|
||||
AUDIOFILE_CONFIG = @AUDIOFILE_CONFIG@
|
||||
AUDIOFILE_LIBS = @AUDIOFILE_LIBS@
|
||||
AWK = @AWK@
|
||||
CC = @CC@
|
||||
CCAS = @CCAS@
|
||||
CCASFLAGS = @CCASFLAGS@
|
||||
CXX = @CXX@
|
||||
CXXCPP = @CXXCPP@
|
||||
DEPDIR = @DEPDIR@
|
||||
DLLTOOL = @DLLTOOL@
|
||||
ECHO = @ECHO@
|
||||
EGREP = @EGREP@
|
||||
F77 = @F77@
|
||||
GCJ = @GCJ@
|
||||
GCJFLAGS = @GCJFLAGS@
|
||||
ID3_LIB = @ID3_LIB@
|
||||
ID3_SUBDIR = @ID3_SUBDIR@
|
||||
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
|
||||
LIBFLAC_CFLAGS = @LIBFLAC_CFLAGS@
|
||||
LIBFLAC_LIBS = @LIBFLAC_LIBS@
|
||||
LIBTOOL = @LIBTOOL@
|
||||
LN_S = @LN_S@
|
||||
MAD_LIB = @MAD_LIB@
|
||||
MAD_SUBDIR = @MAD_SUBDIR@
|
||||
MP4FF_LIB = @MP4FF_LIB@
|
||||
MP4FF_SUBDIR = @MP4FF_SUBDIR@
|
||||
MPD_CFLAGS = @MPD_CFLAGS@
|
||||
MPD_LIBS = @MPD_LIBS@
|
||||
OBJDUMP = @OBJDUMP@
|
||||
OGG_CFLAGS = @OGG_CFLAGS@
|
||||
OGG_LIBS = @OGG_LIBS@
|
||||
PACKAGE = @PACKAGE@
|
||||
RANLIB = @RANLIB@
|
||||
RC = @RC@
|
||||
STRIP = @STRIP@
|
||||
VERSION = @VERSION@
|
||||
VORBISENC_LIBS = @VORBISENC_LIBS@
|
||||
VORBISFILE_LIBS = @VORBISFILE_LIBS@
|
||||
VORBIS_CFLAGS = @VORBIS_CFLAGS@
|
||||
VORBIS_LIBS = @VORBIS_LIBS@
|
||||
am__include = @am__include@
|
||||
am__quote = @am__quote@
|
||||
install_sh = @install_sh@
|
||||
noinst_LTLIBRARIES = libmp4ff.la
|
||||
|
||||
noinst_HEADERS = mp4ff.h
|
||||
|
||||
libmp4ff_la_SOURCES = mp4ff.c mp4atom.c mp4meta.c mp4sample.c mp4util.c \
|
||||
mp4tagupdate.c mp4ff.h mp4ffint.h mp4ff_int_types.h \
|
||||
drms.h drms.c drmstables.h
|
||||
|
||||
subdir = src/mp4ff
|
||||
mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
|
||||
CONFIG_CLEAN_FILES =
|
||||
LTLIBRARIES = $(noinst_LTLIBRARIES)
|
||||
|
||||
libmp4ff_la_LDFLAGS =
|
||||
libmp4ff_la_LIBADD =
|
||||
am_libmp4ff_la_OBJECTS = mp4ff.lo mp4atom.lo mp4meta.lo mp4sample.lo \
|
||||
mp4util.lo mp4tagupdate.lo drms.lo
|
||||
libmp4ff_la_OBJECTS = $(am_libmp4ff_la_OBJECTS)
|
||||
|
||||
DEFS = @DEFS@
|
||||
DEFAULT_INCLUDES = -I. -I$(srcdir)
|
||||
CPPFLAGS = @CPPFLAGS@
|
||||
LDFLAGS = @LDFLAGS@
|
||||
LIBS = @LIBS@
|
||||
depcomp = $(SHELL) $(top_srcdir)/depcomp
|
||||
am__depfiles_maybe = depfiles
|
||||
@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/drms.Plo ./$(DEPDIR)/mp4atom.Plo \
|
||||
@AMDEP_TRUE@ ./$(DEPDIR)/mp4ff.Plo ./$(DEPDIR)/mp4meta.Plo \
|
||||
@AMDEP_TRUE@ ./$(DEPDIR)/mp4sample.Plo \
|
||||
@AMDEP_TRUE@ ./$(DEPDIR)/mp4tagupdate.Plo \
|
||||
@AMDEP_TRUE@ ./$(DEPDIR)/mp4util.Plo
|
||||
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
|
||||
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
|
||||
LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) \
|
||||
$(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
|
||||
CCLD = $(CC)
|
||||
LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
|
||||
$(AM_LDFLAGS) $(LDFLAGS) -o $@
|
||||
CFLAGS = @CFLAGS@
|
||||
DIST_SOURCES = $(libmp4ff_la_SOURCES)
|
||||
HEADERS = $(noinst_HEADERS)
|
||||
|
||||
DIST_COMMON = $(noinst_HEADERS) Makefile.am Makefile.in
|
||||
SOURCES = $(libmp4ff_la_SOURCES)
|
||||
|
||||
all: all-am
|
||||
|
||||
.SUFFIXES:
|
||||
.SUFFIXES: .c .lo .o .obj
|
||||
$(srcdir)/Makefile.in: Makefile.am $(top_srcdir)/configure.ac $(ACLOCAL_M4)
|
||||
cd $(top_srcdir) && \
|
||||
$(AUTOMAKE) --gnu src/mp4ff/Makefile
|
||||
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
|
||||
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)
|
||||
|
||||
clean-noinstLTLIBRARIES:
|
||||
-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
|
||||
@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
|
||||
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
|
||||
test -z "$dir" && dir=.; \
|
||||
echo "rm -f \"$${dir}/so_locations\""; \
|
||||
rm -f "$${dir}/so_locations"; \
|
||||
done
|
||||
libmp4ff.la: $(libmp4ff_la_OBJECTS) $(libmp4ff_la_DEPENDENCIES)
|
||||
$(LINK) $(libmp4ff_la_LDFLAGS) $(libmp4ff_la_OBJECTS) $(libmp4ff_la_LIBADD) $(LIBS)
|
||||
|
||||
mostlyclean-compile:
|
||||
-rm -f *.$(OBJEXT) core *.core
|
||||
|
||||
distclean-compile:
|
||||
-rm -f *.tab.c
|
||||
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/drms.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mp4atom.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mp4ff.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mp4meta.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mp4sample.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mp4tagupdate.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mp4util.Plo@am__quote@
|
||||
|
||||
distclean-depend:
|
||||
-rm -rf ./$(DEPDIR)
|
||||
|
||||
.c.o:
|
||||
@AMDEP_TRUE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
$(COMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$<
|
||||
|
||||
.c.obj:
|
||||
@AMDEP_TRUE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
$(COMPILE) -c `cygpath -w $<`
|
||||
|
||||
.c.lo:
|
||||
@AMDEP_TRUE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
$(LTCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<
|
||||
CCDEPMODE = @CCDEPMODE@
|
||||
|
||||
mostlyclean-libtool:
|
||||
-rm -f *.lo
|
||||
|
||||
clean-libtool:
|
||||
-rm -rf .libs _libs
|
||||
|
||||
distclean-libtool:
|
||||
-rm -f libtool
|
||||
uninstall-info-am:
|
||||
|
||||
ETAGS = etags
|
||||
ETAGSFLAGS =
|
||||
|
||||
tags: TAGS
|
||||
|
||||
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
|
||||
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
|
||||
unique=`for i in $$list; do \
|
||||
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
|
||||
done | \
|
||||
$(AWK) ' { files[$$0] = 1; } \
|
||||
END { for (i in files) print i; }'`; \
|
||||
mkid -fID $$unique
|
||||
|
||||
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
|
||||
$(TAGS_FILES) $(LISP)
|
||||
tags=; \
|
||||
here=`pwd`; \
|
||||
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
|
||||
unique=`for i in $$list; do \
|
||||
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
|
||||
done | \
|
||||
$(AWK) ' { files[$$0] = 1; } \
|
||||
END { for (i in files) print i; }'`; \
|
||||
test -z "$(ETAGS_ARGS)$$tags$$unique" \
|
||||
|| $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
|
||||
$$tags $$unique
|
||||
|
||||
GTAGS:
|
||||
here=`$(am__cd) $(top_builddir) && pwd` \
|
||||
&& cd $(top_srcdir) \
|
||||
&& gtags -i $(GTAGS_ARGS) $$here
|
||||
|
||||
distclean-tags:
|
||||
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH
|
||||
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
|
||||
|
||||
top_distdir = ../..
|
||||
distdir = $(top_distdir)/$(PACKAGE)-$(VERSION)
|
||||
|
||||
distdir: $(DISTFILES)
|
||||
@list='$(DISTFILES)'; for file in $$list; do \
|
||||
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
|
||||
dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
|
||||
if test "$$dir" != "$$file" && test "$$dir" != "."; then \
|
||||
dir="/$$dir"; \
|
||||
$(mkinstalldirs) "$(distdir)$$dir"; \
|
||||
else \
|
||||
dir=''; \
|
||||
fi; \
|
||||
if test -d $$d/$$file; then \
|
||||
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
|
||||
cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
|
||||
fi; \
|
||||
cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
|
||||
else \
|
||||
test -f $(distdir)/$$file \
|
||||
|| cp -p $$d/$$file $(distdir)/$$file \
|
||||
|| exit 1; \
|
||||
fi; \
|
||||
done
|
||||
check-am: all-am
|
||||
check: check-am
|
||||
all-am: Makefile $(LTLIBRARIES) $(HEADERS)
|
||||
|
||||
installdirs:
|
||||
|
||||
install: install-am
|
||||
install-exec: install-exec-am
|
||||
install-data: install-data-am
|
||||
uninstall: uninstall-am
|
||||
|
||||
install-am: all-am
|
||||
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
|
||||
|
||||
installcheck: installcheck-am
|
||||
install-strip:
|
||||
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
|
||||
INSTALL_STRIP_FLAG=-s \
|
||||
`test -z '$(STRIP)' || \
|
||||
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
|
||||
mostlyclean-generic:
|
||||
|
||||
clean-generic:
|
||||
|
||||
distclean-generic:
|
||||
-rm -f Makefile $(CONFIG_CLEAN_FILES)
|
||||
|
||||
maintainer-clean-generic:
|
||||
@echo "This command is intended for maintainers to use"
|
||||
@echo "it deletes files that may require special tools to rebuild."
|
||||
clean: clean-am
|
||||
|
||||
clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
|
||||
mostlyclean-am
|
||||
|
||||
distclean: distclean-am
|
||||
|
||||
distclean-am: clean-am distclean-compile distclean-depend \
|
||||
distclean-generic distclean-libtool distclean-tags
|
||||
|
||||
dvi: dvi-am
|
||||
|
||||
dvi-am:
|
||||
|
||||
info: info-am
|
||||
|
||||
info-am:
|
||||
|
||||
install-data-am:
|
||||
|
||||
install-exec-am:
|
||||
|
||||
install-info: install-info-am
|
||||
|
||||
install-man:
|
||||
|
||||
installcheck-am:
|
||||
|
||||
maintainer-clean: maintainer-clean-am
|
||||
|
||||
maintainer-clean-am: distclean-am maintainer-clean-generic
|
||||
|
||||
mostlyclean: mostlyclean-am
|
||||
|
||||
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
|
||||
mostlyclean-libtool
|
||||
|
||||
uninstall-am: uninstall-info-am
|
||||
|
||||
.PHONY: GTAGS all all-am check check-am clean clean-generic \
|
||||
clean-libtool clean-noinstLTLIBRARIES distclean \
|
||||
distclean-compile distclean-depend distclean-generic \
|
||||
distclean-libtool distclean-tags distdir dvi dvi-am info \
|
||||
info-am install install-am install-data install-data-am \
|
||||
install-exec install-exec-am install-info install-info-am \
|
||||
install-man install-strip installcheck installcheck-am \
|
||||
installdirs maintainer-clean maintainer-clean-generic \
|
||||
mostlyclean mostlyclean-compile mostlyclean-generic \
|
||||
mostlyclean-libtool tags uninstall uninstall-am \
|
||||
uninstall-info-am
|
||||
|
||||
# Tell versions [3.59,3.63) of GNU make to not export all variables.
|
||||
# Otherwise a system limit (for SysV at least) may be exceeded.
|
||||
.NOEXPORT:
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,40 @@
|
|||
/*****************************************************************************
|
||||
* drms.h : DRMS
|
||||
*****************************************************************************
|
||||
* Copyright (C) 2004 VideoLAN
|
||||
* $Id: drms.h,v 1.3 2004/01/11 15:52:18 menno Exp $
|
||||
*
|
||||
* Author: Jon Lech Johansen <jon-vl@nanocrew.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
|
||||
*****************************************************************************/
|
||||
|
||||
|
||||
#define DRMS_INIT_UKEY 0
|
||||
#define DRMS_INIT_IVIV 1
|
||||
#define DRMS_INIT_NAME 2
|
||||
#define DRMS_INIT_PRIV 3
|
||||
|
||||
extern int drms_get_sys_key( uint32_t *p_sys_key );
|
||||
extern int drms_get_user_key( uint32_t *p_sys_key,
|
||||
uint32_t *p_user_key );
|
||||
|
||||
extern void *drms_alloc();
|
||||
extern void drms_free( void *p_drms );
|
||||
extern int drms_init( void *p_drms, uint32_t i_type,
|
||||
uint8_t *p_info, uint32_t i_len );
|
||||
extern void drms_decrypt( void *p_drms, uint32_t *p_buffer,
|
||||
uint32_t i_len );
|
||||
|
||||
|
|
@ -0,0 +1,449 @@
|
|||
/*****************************************************************************
|
||||
* drmstables.h : DRMS tables
|
||||
*****************************************************************************
|
||||
* Copyright (C) 2004 VideoLAN
|
||||
* $Id: drmstables.h,v 1.2 2004/01/11 15:52:18 menno Exp $
|
||||
*
|
||||
* Author: Jon Lech Johansen <jon-vl@nanocrew.net>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
|
||||
*****************************************************************************/
|
||||
|
||||
|
||||
static uint32_t p_drms_tab1[ 10 ] =
|
||||
{
|
||||
0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020,
|
||||
0x00000040, 0x00000080, 0x0000001B, 0x00000036
|
||||
};
|
||||
|
||||
static uint32_t p_drms_tab2[ 256 ] =
|
||||
{
|
||||
0x63000000, 0x7C000000, 0x77000000, 0x7B000000, 0xF2000000, 0x6B000000,
|
||||
0x6F000000, 0xC5000000, 0x30000000, 0x01000000, 0x67000000, 0x2B000000,
|
||||
0xFE000000, 0xD7000000, 0xAB000000, 0x76000000, 0xCA000000, 0x82000000,
|
||||
0xC9000000, 0x7D000000, 0xFA000000, 0x59000000, 0x47000000, 0xF0000000,
|
||||
0xAD000000, 0xD4000000, 0xA2000000, 0xAF000000, 0x9C000000, 0xA4000000,
|
||||
0x72000000, 0xC0000000, 0xB7000000, 0xFD000000, 0x93000000, 0x26000000,
|
||||
0x36000000, 0x3F000000, 0xF7000000, 0xCC000000, 0x34000000, 0xA5000000,
|
||||
0xE5000000, 0xF1000000, 0x71000000, 0xD8000000, 0x31000000, 0x15000000,
|
||||
0x04000000, 0xC7000000, 0x23000000, 0xC3000000, 0x18000000, 0x96000000,
|
||||
0x05000000, 0x9A000000, 0x07000000, 0x12000000, 0x80000000, 0xE2000000,
|
||||
0xEB000000, 0x27000000, 0xB2000000, 0x75000000, 0x09000000, 0x83000000,
|
||||
0x2C000000, 0x1A000000, 0x1B000000, 0x6E000000, 0x5A000000, 0xA0000000,
|
||||
0x52000000, 0x3B000000, 0xD6000000, 0xB3000000, 0x29000000, 0xE3000000,
|
||||
0x2F000000, 0x84000000, 0x53000000, 0xD1000000, 0x00000000, 0xED000000,
|
||||
0x20000000, 0xFC000000, 0xB1000000, 0x5B000000, 0x6A000000, 0xCB000000,
|
||||
0xBE000000, 0x39000000, 0x4A000000, 0x4C000000, 0x58000000, 0xCF000000,
|
||||
0xD0000000, 0xEF000000, 0xAA000000, 0xFB000000, 0x43000000, 0x4D000000,
|
||||
0x33000000, 0x85000000, 0x45000000, 0xF9000000, 0x02000000, 0x7F000000,
|
||||
0x50000000, 0x3C000000, 0x9F000000, 0xA8000000, 0x51000000, 0xA3000000,
|
||||
0x40000000, 0x8F000000, 0x92000000, 0x9D000000, 0x38000000, 0xF5000000,
|
||||
0xBC000000, 0xB6000000, 0xDA000000, 0x21000000, 0x10000000, 0xFF000000,
|
||||
0xF3000000, 0xD2000000, 0xCD000000, 0x0C000000, 0x13000000, 0xEC000000,
|
||||
0x5F000000, 0x97000000, 0x44000000, 0x17000000, 0xC4000000, 0xA7000000,
|
||||
0x7E000000, 0x3D000000, 0x64000000, 0x5D000000, 0x19000000, 0x73000000,
|
||||
0x60000000, 0x81000000, 0x4F000000, 0xDC000000, 0x22000000, 0x2A000000,
|
||||
0x90000000, 0x88000000, 0x46000000, 0xEE000000, 0xB8000000, 0x14000000,
|
||||
0xDE000000, 0x5E000000, 0x0B000000, 0xDB000000, 0xE0000000, 0x32000000,
|
||||
0x3A000000, 0x0A000000, 0x49000000, 0x06000000, 0x24000000, 0x5C000000,
|
||||
0xC2000000, 0xD3000000, 0xAC000000, 0x62000000, 0x91000000, 0x95000000,
|
||||
0xE4000000, 0x79000000, 0xE7000000, 0xC8000000, 0x37000000, 0x6D000000,
|
||||
0x8D000000, 0xD5000000, 0x4E000000, 0xA9000000, 0x6C000000, 0x56000000,
|
||||
0xF4000000, 0xEA000000, 0x65000000, 0x7A000000, 0xAE000000, 0x08000000,
|
||||
0xBA000000, 0x78000000, 0x25000000, 0x2E000000, 0x1C000000, 0xA6000000,
|
||||
0xB4000000, 0xC6000000, 0xE8000000, 0xDD000000, 0x74000000, 0x1F000000,
|
||||
0x4B000000, 0xBD000000, 0x8B000000, 0x8A000000, 0x70000000, 0x3E000000,
|
||||
0xB5000000, 0x66000000, 0x48000000, 0x03000000, 0xF6000000, 0x0E000000,
|
||||
0x61000000, 0x35000000, 0x57000000, 0xB9000000, 0x86000000, 0xC1000000,
|
||||
0x1D000000, 0x9E000000, 0xE1000000, 0xF8000000, 0x98000000, 0x11000000,
|
||||
0x69000000, 0xD9000000, 0x8E000000, 0x94000000, 0x9B000000, 0x1E000000,
|
||||
0x87000000, 0xE9000000, 0xCE000000, 0x55000000, 0x28000000, 0xDF000000,
|
||||
0x8C000000, 0xA1000000, 0x89000000, 0x0D000000, 0xBF000000, 0xE6000000,
|
||||
0x42000000, 0x68000000, 0x41000000, 0x99000000, 0x2D000000, 0x0F000000,
|
||||
0xB0000000, 0x54000000, 0xBB000000, 0x16000000
|
||||
};
|
||||
|
||||
static uint32_t p_drms_tab3[ 256 ] =
|
||||
{
|
||||
0x5150A7F4, 0x7E536541, 0x1AC3A417, 0x3A965E27, 0x3BCB6BAB, 0x1FF1459D,
|
||||
0xACAB58FA, 0x4B9303E3, 0x2055FA30, 0xADF66D76, 0x889176CC, 0xF5254C02,
|
||||
0x4FFCD7E5, 0xC5D7CB2A, 0x26804435, 0xB58FA362, 0xDE495AB1, 0x25671BBA,
|
||||
0x45980EEA, 0x5DE1C0FE, 0xC302752F, 0x8112F04C, 0x8DA39746, 0x6BC6F9D3,
|
||||
0x03E75F8F, 0x15959C92, 0xBFEB7A6D, 0x95DA5952, 0xD42D83BE, 0x58D32174,
|
||||
0x492969E0, 0x8E44C8C9, 0x756A89C2, 0xF478798E, 0x996B3E58, 0x27DD71B9,
|
||||
0xBEB64FE1, 0xF017AD88, 0xC966AC20, 0x7DB43ACE, 0x63184ADF, 0xE582311A,
|
||||
0x97603351, 0x62457F53, 0xB1E07764, 0xBB84AE6B, 0xFE1CA081, 0xF9942B08,
|
||||
0x70586848, 0x8F19FD45, 0x94876CDE, 0x52B7F87B, 0xAB23D373, 0x72E2024B,
|
||||
0xE3578F1F, 0x662AAB55, 0xB20728EB, 0x2F03C2B5, 0x869A7BC5, 0xD3A50837,
|
||||
0x30F28728, 0x23B2A5BF, 0x02BA6A03, 0xED5C8216, 0x8A2B1CCF, 0xA792B479,
|
||||
0xF3F0F207, 0x4EA1E269, 0x65CDF4DA, 0x06D5BE05, 0xD11F6234, 0xC48AFEA6,
|
||||
0x349D532E, 0xA2A055F3, 0x0532E18A, 0xA475EBF6, 0x0B39EC83, 0x40AAEF60,
|
||||
0x5E069F71, 0xBD51106E, 0x3EF98A21, 0x963D06DD, 0xDDAE053E, 0x4D46BDE6,
|
||||
0x91B58D54, 0x71055DC4, 0x046FD406, 0x60FF1550, 0x1924FB98, 0xD697E9BD,
|
||||
0x89CC4340, 0x67779ED9, 0xB0BD42E8, 0x07888B89, 0xE7385B19, 0x79DBEEC8,
|
||||
0xA1470A7C, 0x7CE90F42, 0xF8C91E84, 0x00000000, 0x09838680, 0x3248ED2B,
|
||||
0x1EAC7011, 0x6C4E725A, 0xFDFBFF0E, 0x0F563885, 0x3D1ED5AE, 0x3627392D,
|
||||
0x0A64D90F, 0x6821A65C, 0x9BD1545B, 0x243A2E36, 0x0CB1670A, 0x930FE757,
|
||||
0xB4D296EE, 0x1B9E919B, 0x804FC5C0, 0x61A220DC, 0x5A694B77, 0x1C161A12,
|
||||
0xE20ABA93, 0xC0E52AA0, 0x3C43E022, 0x121D171B, 0x0E0B0D09, 0xF2ADC78B,
|
||||
0x2DB9A8B6, 0x14C8A91E, 0x578519F1, 0xAF4C0775, 0xEEBBDD99, 0xA3FD607F,
|
||||
0xF79F2601, 0x5CBCF572, 0x44C53B66, 0x5B347EFB, 0x8B762943, 0xCBDCC623,
|
||||
0xB668FCED, 0xB863F1E4, 0xD7CADC31, 0x42108563, 0x13402297, 0x842011C6,
|
||||
0x857D244A, 0xD2F83DBB, 0xAE1132F9, 0xC76DA129, 0x1D4B2F9E, 0xDCF330B2,
|
||||
0x0DEC5286, 0x77D0E3C1, 0x2B6C16B3, 0xA999B970, 0x11FA4894, 0x472264E9,
|
||||
0xA8C48CFC, 0xA01A3FF0, 0x56D82C7D, 0x22EF9033, 0x87C74E49, 0xD9C1D138,
|
||||
0x8CFEA2CA, 0x98360BD4, 0xA6CF81F5, 0xA528DE7A, 0xDA268EB7, 0x3FA4BFAD,
|
||||
0x2CE49D3A, 0x500D9278, 0x6A9BCC5F, 0x5462467E, 0xF6C2138D, 0x90E8B8D8,
|
||||
0x2E5EF739, 0x82F5AFC3, 0x9FBE805D, 0x697C93D0, 0x6FA92DD5, 0xCFB31225,
|
||||
0xC83B99AC, 0x10A77D18, 0xE86E639C, 0xDB7BBB3B, 0xCD097826, 0x6EF41859,
|
||||
0xEC01B79A, 0x83A89A4F, 0xE6656E95, 0xAA7EE6FF, 0x2108CFBC, 0xEFE6E815,
|
||||
0xBAD99BE7, 0x4ACE366F, 0xEAD4099F, 0x29D67CB0, 0x31AFB2A4, 0x2A31233F,
|
||||
0xC63094A5, 0x35C066A2, 0x7437BC4E, 0xFCA6CA82, 0xE0B0D090, 0x3315D8A7,
|
||||
0xF14A9804, 0x41F7DAEC, 0x7F0E50CD, 0x172FF691, 0x768DD64D, 0x434DB0EF,
|
||||
0xCC544DAA, 0xE4DF0496, 0x9EE3B5D1, 0x4C1B886A, 0xC1B81F2C, 0x467F5165,
|
||||
0x9D04EA5E, 0x015D358C, 0xFA737487, 0xFB2E410B, 0xB35A1D67, 0x9252D2DB,
|
||||
0xE9335610, 0x6D1347D6, 0x9A8C61D7, 0x377A0CA1, 0x598E14F8, 0xEB893C13,
|
||||
0xCEEE27A9, 0xB735C961, 0xE1EDE51C, 0x7A3CB147, 0x9C59DFD2, 0x553F73F2,
|
||||
0x1879CE14, 0x73BF37C7, 0x53EACDF7, 0x5F5BAAFD, 0xDF146F3D, 0x7886DB44,
|
||||
0xCA81F3AF, 0xB93EC468, 0x382C3424, 0xC25F40A3, 0x1672C31D, 0xBC0C25E2,
|
||||
0x288B493C, 0xFF41950D, 0x397101A8, 0x08DEB30C, 0xD89CE4B4, 0x6490C156,
|
||||
0x7B6184CB, 0xD570B632, 0x48745C6C, 0xD04257B8
|
||||
};
|
||||
|
||||
static uint32_t p_drms_tab4[ 256 ] =
|
||||
{
|
||||
0x52000000, 0x09000000, 0x6A000000, 0xD5000000, 0x30000000, 0x36000000,
|
||||
0xA5000000, 0x38000000, 0xBF000000, 0x40000000, 0xA3000000, 0x9E000000,
|
||||
0x81000000, 0xF3000000, 0xD7000000, 0xFB000000, 0x7C000000, 0xE3000000,
|
||||
0x39000000, 0x82000000, 0x9B000000, 0x2F000000, 0xFF000000, 0x87000000,
|
||||
0x34000000, 0x8E000000, 0x43000000, 0x44000000, 0xC4000000, 0xDE000000,
|
||||
0xE9000000, 0xCB000000, 0x54000000, 0x7B000000, 0x94000000, 0x32000000,
|
||||
0xA6000000, 0xC2000000, 0x23000000, 0x3D000000, 0xEE000000, 0x4C000000,
|
||||
0x95000000, 0x0B000000, 0x42000000, 0xFA000000, 0xC3000000, 0x4E000000,
|
||||
0x08000000, 0x2E000000, 0xA1000000, 0x66000000, 0x28000000, 0xD9000000,
|
||||
0x24000000, 0xB2000000, 0x76000000, 0x5B000000, 0xA2000000, 0x49000000,
|
||||
0x6D000000, 0x8B000000, 0xD1000000, 0x25000000, 0x72000000, 0xF8000000,
|
||||
0xF6000000, 0x64000000, 0x86000000, 0x68000000, 0x98000000, 0x16000000,
|
||||
0xD4000000, 0xA4000000, 0x5C000000, 0xCC000000, 0x5D000000, 0x65000000,
|
||||
0xB6000000, 0x92000000, 0x6C000000, 0x70000000, 0x48000000, 0x50000000,
|
||||
0xFD000000, 0xED000000, 0xB9000000, 0xDA000000, 0x5E000000, 0x15000000,
|
||||
0x46000000, 0x57000000, 0xA7000000, 0x8D000000, 0x9D000000, 0x84000000,
|
||||
0x90000000, 0xD8000000, 0xAB000000, 0x00000000, 0x8C000000, 0xBC000000,
|
||||
0xD3000000, 0x0A000000, 0xF7000000, 0xE4000000, 0x58000000, 0x05000000,
|
||||
0xB8000000, 0xB3000000, 0x45000000, 0x06000000, 0xD0000000, 0x2C000000,
|
||||
0x1E000000, 0x8F000000, 0xCA000000, 0x3F000000, 0x0F000000, 0x02000000,
|
||||
0xC1000000, 0xAF000000, 0xBD000000, 0x03000000, 0x01000000, 0x13000000,
|
||||
0x8A000000, 0x6B000000, 0x3A000000, 0x91000000, 0x11000000, 0x41000000,
|
||||
0x4F000000, 0x67000000, 0xDC000000, 0xEA000000, 0x97000000, 0xF2000000,
|
||||
0xCF000000, 0xCE000000, 0xF0000000, 0xB4000000, 0xE6000000, 0x73000000,
|
||||
0x96000000, 0xAC000000, 0x74000000, 0x22000000, 0xE7000000, 0xAD000000,
|
||||
0x35000000, 0x85000000, 0xE2000000, 0xF9000000, 0x37000000, 0xE8000000,
|
||||
0x1C000000, 0x75000000, 0xDF000000, 0x6E000000, 0x47000000, 0xF1000000,
|
||||
0x1A000000, 0x71000000, 0x1D000000, 0x29000000, 0xC5000000, 0x89000000,
|
||||
0x6F000000, 0xB7000000, 0x62000000, 0x0E000000, 0xAA000000, 0x18000000,
|
||||
0xBE000000, 0x1B000000, 0xFC000000, 0x56000000, 0x3E000000, 0x4B000000,
|
||||
0xC6000000, 0xD2000000, 0x79000000, 0x20000000, 0x9A000000, 0xDB000000,
|
||||
0xC0000000, 0xFE000000, 0x78000000, 0xCD000000, 0x5A000000, 0xF4000000,
|
||||
0x1F000000, 0xDD000000, 0xA8000000, 0x33000000, 0x88000000, 0x07000000,
|
||||
0xC7000000, 0x31000000, 0xB1000000, 0x12000000, 0x10000000, 0x59000000,
|
||||
0x27000000, 0x80000000, 0xEC000000, 0x5F000000, 0x60000000, 0x51000000,
|
||||
0x7F000000, 0xA9000000, 0x19000000, 0xB5000000, 0x4A000000, 0x0D000000,
|
||||
0x2D000000, 0xE5000000, 0x7A000000, 0x9F000000, 0x93000000, 0xC9000000,
|
||||
0x9C000000, 0xEF000000, 0xA0000000, 0xE0000000, 0x3B000000, 0x4D000000,
|
||||
0xAE000000, 0x2A000000, 0xF5000000, 0xB0000000, 0xC8000000, 0xEB000000,
|
||||
0xBB000000, 0x3C000000, 0x83000000, 0x53000000, 0x99000000, 0x61000000,
|
||||
0x17000000, 0x2B000000, 0x04000000, 0x7E000000, 0xBA000000, 0x77000000,
|
||||
0xD6000000, 0x26000000, 0xE1000000, 0x69000000, 0x14000000, 0x63000000,
|
||||
0x55000000, 0x21000000, 0x0C000000, 0x7D000000
|
||||
};
|
||||
|
||||
static int32_t p_drms_tab_taos[ 64 ] =
|
||||
{
|
||||
-0x28955B88, -0x173848AA, +0x242070DB, -0x3E423112, -0x0A83F051,
|
||||
+0x4787C62A, -0x57CFB9ED, -0x02B96AFF, +0x698098D8, -0x74BB0851,
|
||||
-0x0000A44F, -0x76A32842, +0x6B901122, -0x02678E6D, -0x5986BC72,
|
||||
+0x49B40821, -0x09E1DA9E, -0x3FBF4CC0, +0x265E5A51, -0x16493856,
|
||||
-0x29D0EFA3, +0x02441453, -0x275E197F, -0x182C0438, +0x21E1CDE6,
|
||||
-0x3CC8F82A, -0x0B2AF279, +0x455A14ED, -0x561C16FB, -0x03105C08,
|
||||
+0x676F02D9, -0x72D5B376, -0x0005C6BE, -0x788E097F, +0x6D9D6122,
|
||||
-0x021AC7F4, -0x5B4115BC, +0x4BDECFA9, -0x0944B4A0, -0x41404390,
|
||||
+0x289B7EC6, -0x155ED806, -0x2B10CF7B, +0x04881D05, -0x262B2FC7,
|
||||
-0x1924661B, +0x1FA27CF8, -0x3B53A99B, -0x0BD6DDBC, +0x432AFF97,
|
||||
-0x546BDC59, -0x036C5FC7, +0x655B59C3, -0x70F3336E, -0x00100B83,
|
||||
-0x7A7BA22F, +0x6FA87E4F, -0x01D31920, -0x5CFEBCEC, +0x4E0811A1,
|
||||
-0x08AC817E, -0x42C50DCB, +0x2AD7D2BB, -0x14792C6F
|
||||
};
|
||||
|
||||
static uint8_t p_drms_tab_tend[ 64 ] =
|
||||
{
|
||||
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
static uint16_t p_drms_tab_xor[ 16 ][ 16 ] =
|
||||
{
|
||||
{
|
||||
0x00D1, 0x0315, 0x1A32, 0x19EC, 0x1BBB, 0x1D6F, 0x14FE, 0x0E9E,
|
||||
0x029E, 0x1B8F, 0x0B70, 0x033A, 0x188E, 0x1D18, 0x0BD8, 0x0EDB
|
||||
},
|
||||
|
||||
{
|
||||
0x0C64, 0x1C2B, 0x149C, 0x047B, 0x1064, 0x1C7C, 0x118D, 0x1355,
|
||||
0x0AE5, 0x0F18, 0x016F, 0x17D6, 0x1595, 0x0084, 0x0616, 0x1CCD
|
||||
},
|
||||
|
||||
{
|
||||
0x1D94, 0x0618, 0x182C, 0x195B, 0x196D, 0x0394, 0x07DB, 0x0287,
|
||||
0x1636, 0x0B81, 0x1519, 0x0DF9, 0x1BA3, 0x1CC3, 0x0EE2, 0x1434
|
||||
},
|
||||
|
||||
{
|
||||
0x1457, 0x0CED, 0x0F7D, 0x0D7B, 0x0B9E, 0x0D13, 0x13D7, 0x18D0,
|
||||
0x1259, 0x1977, 0x0606, 0x1E80, 0x05F2, 0x06B8, 0x1F07, 0x1365
|
||||
},
|
||||
|
||||
{
|
||||
0x0334, 0x0E30, 0x195F, 0x15F1, 0x058E, 0x0AA8, 0x045A, 0x0465,
|
||||
0x0B3E, 0x071E, 0x0A36, 0x105C, 0x01AC, 0x1A1E, 0x04E4, 0x056B
|
||||
},
|
||||
|
||||
{
|
||||
0x12BF, 0x0DA2, 0x0B41, 0x0EAF, 0x034F, 0x0181, 0x04E2, 0x002B,
|
||||
0x12E6, 0x01BE, 0x10E8, 0x128F, 0x0EB2, 0x1369, 0x05BE, 0x1A59
|
||||
},
|
||||
|
||||
{
|
||||
0x117E, 0x047C, 0x1E86, 0x056A, 0x0DA7, 0x0D61, 0x03FC, 0x1E6E,
|
||||
0x1D0C, 0x1E6D, 0x14BF, 0x0C50, 0x063A, 0x1B47, 0x17AE, 0x1321
|
||||
},
|
||||
|
||||
{
|
||||
0x041B, 0x0A24, 0x0D4D, 0x1F2B, 0x1CB6, 0x1BED, 0x1549, 0x03A7,
|
||||
0x0254, 0x006C, 0x0C9E, 0x0F73, 0x006C, 0x0008, 0x11F9, 0x0DD5
|
||||
},
|
||||
|
||||
{
|
||||
0x0BCF, 0x0AF9, 0x1DFE, 0x0341, 0x0E49, 0x0D38, 0x17CB, 0x1513,
|
||||
0x0E96, 0x00ED, 0x0556, 0x1B28, 0x100C, 0x19D8, 0x14FA, 0x028C
|
||||
},
|
||||
|
||||
{
|
||||
0x1C60, 0x1232, 0x13D3, 0x0D00, 0x1534, 0x192C, 0x14B5, 0x1CF2,
|
||||
0x0504, 0x0B5B, 0x1ECF, 0x0423, 0x183B, 0x06B0, 0x169E, 0x1066
|
||||
},
|
||||
|
||||
{
|
||||
0x04CB, 0x08A2, 0x1B4A, 0x1254, 0x198D, 0x1044, 0x0236, 0x1BD8,
|
||||
0x18A1, 0x03FF, 0x1A0D, 0x0277, 0x0C2D, 0x17C9, 0x007C, 0x116E
|
||||
},
|
||||
|
||||
{
|
||||
0x048A, 0x1EAF, 0x0922, 0x0C45, 0x0766, 0x1E5F, 0x1A28, 0x0120,
|
||||
0x1C15, 0x034C, 0x0508, 0x0E73, 0x0879, 0x0441, 0x09AE, 0x132F
|
||||
},
|
||||
|
||||
{
|
||||
0x14FE, 0x0413, 0x0A9D, 0x1727, 0x01D7, 0x1A2B, 0x0474, 0x18F0,
|
||||
0x1F3B, 0x14F5, 0x1071, 0x0895, 0x1071, 0x18FF, 0x18E3, 0x0EB9
|
||||
},
|
||||
|
||||
{
|
||||
0x0BA9, 0x0961, 0x1599, 0x019E, 0x1D12, 0x1BAA, 0x1E94, 0x1921,
|
||||
0x14DC, 0x124E, 0x0A25, 0x03AB, 0x1CC0, 0x1EBB, 0x0B4B, 0x16E5
|
||||
},
|
||||
|
||||
{
|
||||
0x11EA, 0x0D78, 0x1BB3, 0x1BA7, 0x1510, 0x1B7B, 0x0C64, 0x1995,
|
||||
0x1A58, 0x1651, 0x1964, 0x147A, 0x15F2, 0x11BB, 0x1654, 0x166E
|
||||
},
|
||||
|
||||
{
|
||||
0x0EA9, 0x1DE1, 0x1443, 0x13C5, 0x00E1, 0x0B2F, 0x0B6F, 0x0A37,
|
||||
0x18AC, 0x08E6, 0x06F0, 0x136E, 0x0853, 0x0B2E, 0x0813, 0x10D6
|
||||
}
|
||||
};
|
||||
|
||||
static uint16_t p_drms_tab_sub[ 16 ][ 16 ] =
|
||||
{
|
||||
{
|
||||
0x067A, 0x0C7D, 0x0B4F, 0x127D, 0x0BD6, 0x04AC, 0x16E0, 0x1730,
|
||||
0x0587, 0x0AFB, 0x1AC3, 0x0120, 0x14B5, 0x0F67, 0x11DE, 0x0961
|
||||
},
|
||||
|
||||
{
|
||||
0x1127, 0x1A68, 0x07F0, 0x17D0, 0x1A6F, 0x1F3B, 0x01EF, 0x0919,
|
||||
0x131E, 0x0F90, 0x19E9, 0x18A8, 0x0CB2, 0x1AD0, 0x0C66, 0x0378
|
||||
},
|
||||
|
||||
{
|
||||
0x03B0, 0x01BE, 0x1866, 0x1159, 0x197C, 0x1105, 0x010B, 0x0353,
|
||||
0x1ABB, 0x09A6, 0x028A, 0x1BAD, 0x1B20, 0x0455, 0x0F57, 0x0588
|
||||
},
|
||||
|
||||
{
|
||||
0x1491, 0x0A1D, 0x0F04, 0x0650, 0x191E, 0x1E0E, 0x174B, 0x016B,
|
||||
0x051F, 0x0532, 0x00DF, 0x1AEA, 0x0005, 0x0E1B, 0x0FF6, 0x08D8
|
||||
},
|
||||
|
||||
{
|
||||
0x14B4, 0x086A, 0x0C20, 0x0149, 0x1971, 0x0F26, 0x1852, 0x017D,
|
||||
0x1228, 0x0352, 0x0A44, 0x1330, 0x18DF, 0x1E38, 0x01BC, 0x0BAC
|
||||
},
|
||||
|
||||
{
|
||||
0x1A48, 0x021F, 0x02F7, 0x0C31, 0x0BC4, 0x1E75, 0x105C, 0x13E3,
|
||||
0x0B20, 0x03A1, 0x1AF3, 0x1A36, 0x0E34, 0x181F, 0x09BD, 0x122B
|
||||
},
|
||||
|
||||
{
|
||||
0x0EE0, 0x163B, 0x0BE7, 0x103D, 0x1075, 0x1E9D, 0x02AF, 0x0BA2,
|
||||
0x1DAA, 0x0CF1, 0x04B6, 0x0598, 0x06A1, 0x0D33, 0x1CFE, 0x04EE
|
||||
},
|
||||
|
||||
{
|
||||
0x1BAD, 0x07C8, 0x1A48, 0x05E6, 0x031F, 0x0E0A, 0x0326, 0x1650,
|
||||
0x0526, 0x0B4E, 0x08FC, 0x0E4D, 0x0832, 0x06EA, 0x09BF, 0x0993
|
||||
},
|
||||
|
||||
{
|
||||
0x09EB, 0x0F31, 0x071B, 0x14D5, 0x11CA, 0x0722, 0x120D, 0x014C,
|
||||
0x1993, 0x0AE4, 0x1CCB, 0x04E9, 0x0AEE, 0x1708, 0x0C3D, 0x12F2
|
||||
},
|
||||
|
||||
{
|
||||
0x1A19, 0x07C1, 0x05A7, 0x0744, 0x1606, 0x1A9B, 0x042D, 0x1BFC,
|
||||
0x1841, 0x0C3C, 0x0FFE, 0x1AB1, 0x1416, 0x18A9, 0x0320, 0x1EC2
|
||||
},
|
||||
|
||||
{
|
||||
0x0AE7, 0x11C6, 0x124A, 0x11DF, 0x0F81, 0x06CF, 0x0ED9, 0x0253,
|
||||
0x1D2B, 0x0349, 0x0805, 0x08B3, 0x1052, 0x12CF, 0x0A44, 0x0EA6
|
||||
},
|
||||
|
||||
{
|
||||
0x03BF, 0x1D90, 0x0EF8, 0x0657, 0x156D, 0x0405, 0x10BE, 0x091F,
|
||||
0x1C82, 0x1725, 0x19EF, 0x0B8C, 0x04D9, 0x02C7, 0x025A, 0x1B89
|
||||
},
|
||||
|
||||
{
|
||||
0x0F5C, 0x013D, 0x02F7, 0x12E3, 0x0BC5, 0x1B56, 0x0848, 0x0239,
|
||||
0x0FCF, 0x03A4, 0x092D, 0x1354, 0x1D83, 0x01BD, 0x071A, 0x0AF1
|
||||
},
|
||||
|
||||
{
|
||||
0x0875, 0x0793, 0x1B41, 0x1782, 0x0DEF, 0x1D20, 0x13BE, 0x0095,
|
||||
0x1650, 0x19D4, 0x0DE3, 0x0980, 0x18F2, 0x0CA3, 0x0098, 0x149A
|
||||
},
|
||||
|
||||
{
|
||||
0x0B81, 0x0AD2, 0x1BBA, 0x1A02, 0x027B, 0x1906, 0x07F5, 0x1CAE,
|
||||
0x0C3F, 0x02F6, 0x1298, 0x175E, 0x15B2, 0x13D8, 0x14CC, 0x161A
|
||||
},
|
||||
|
||||
{
|
||||
0x0A42, 0x15F3, 0x0870, 0x1C1D, 0x1203, 0x18B1, 0x1738, 0x1954,
|
||||
0x1143, 0x1AE8, 0x1D9D, 0x155B, 0x11E8, 0x0ED9, 0x06F7, 0x04CA
|
||||
}
|
||||
};
|
||||
|
||||
static uint16_t p_drms_tab_add[ 16 ][ 16 ] =
|
||||
{
|
||||
{
|
||||
0x0706, 0x175A, 0x0DEF, 0x1E72, 0x0297, 0x1B0E, 0x1D5A, 0x15B8,
|
||||
0x13E2, 0x1347, 0x10C6, 0x0B4F, 0x0629, 0x0A75, 0x0A9B, 0x0F55
|
||||
},
|
||||
|
||||
{
|
||||
0x1A69, 0x09BF, 0x0BA6, 0x1582, 0x1086, 0x1921, 0x01CB, 0x1C6A,
|
||||
0x0FF5, 0x00F7, 0x0A67, 0x0A1E, 0x1838, 0x0196, 0x10D6, 0x0C7A
|
||||
},
|
||||
|
||||
{
|
||||
0x180E, 0x038D, 0x1ADD, 0x0684, 0x154A, 0x0AB0, 0x18A4, 0x0D73,
|
||||
0x1641, 0x0EC6, 0x09F1, 0x1A62, 0x0414, 0x162A, 0x194E, 0x1EC9
|
||||
},
|
||||
|
||||
{
|
||||
0x022F, 0x0296, 0x1104, 0x14FC, 0x096C, 0x1D02, 0x09BD, 0x027C,
|
||||
0x080E, 0x1324, 0x128C, 0x0DC1, 0x00B9, 0x17F2, 0x0CBC, 0x0F97
|
||||
},
|
||||
|
||||
{
|
||||
0x1B93, 0x1C3C, 0x0415, 0x0395, 0x0C7A, 0x06CC, 0x0D4B, 0x16E2,
|
||||
0x04A2, 0x0DAB, 0x1228, 0x012B, 0x0896, 0x0012, 0x1CD6, 0x1DAC
|
||||
},
|
||||
|
||||
{
|
||||
0x080D, 0x0446, 0x047A, 0x00AD, 0x029E, 0x0686, 0x17C3, 0x1466,
|
||||
0x0D16, 0x1896, 0x076E, 0x00CD, 0x17DC, 0x1E9F, 0x1A7C, 0x02BB
|
||||
},
|
||||
|
||||
{
|
||||
0x0D06, 0x112B, 0x14CB, 0x0A03, 0x1541, 0x1290, 0x0F6D, 0x1503,
|
||||
0x084B, 0x0382, 0x1A3F, 0x0371, 0x1977, 0x0B67, 0x0CAD, 0x1DF8
|
||||
},
|
||||
|
||||
{
|
||||
0x1CE3, 0x1306, 0x13F8, 0x1163, 0x1B0B, 0x00BD, 0x0BF0, 0x1A4F,
|
||||
0x16F7, 0x0B4F, 0x0CF8, 0x1254, 0x0541, 0x100D, 0x0296, 0x0410
|
||||
},
|
||||
|
||||
{
|
||||
0x1A2B, 0x1169, 0x17D9, 0x0819, 0x03D6, 0x0D03, 0x194D, 0x184A,
|
||||
0x07CA, 0x1989, 0x0FAD, 0x011C, 0x1C71, 0x0EF6, 0x0DC8, 0x0F2F
|
||||
},
|
||||
|
||||
{
|
||||
0x0FA5, 0x11BE, 0x0F3B, 0x1D52, 0x0DE2, 0x016E, 0x1AD1, 0x0C4A,
|
||||
0x1BC2, 0x0AC9, 0x1485, 0x1BEE, 0x0949, 0x1A79, 0x1894, 0x12BB
|
||||
},
|
||||
|
||||
{
|
||||
0x17B6, 0x14F5, 0x16B1, 0x142C, 0x1301, 0x03EF, 0x16FF, 0x0D37,
|
||||
0x0D78, 0x01FF, 0x00D6, 0x1053, 0x1A2A, 0x0F61, 0x1352, 0x0C7F
|
||||
},
|
||||
|
||||
{
|
||||
0x137F, 0x09C4, 0x1D96, 0x021D, 0x1037, 0x1B19, 0x10EF, 0x14E4,
|
||||
0x02A0, 0x0236, 0x0A5D, 0x1519, 0x141C, 0x1399, 0x007E, 0x1E74
|
||||
},
|
||||
|
||||
{
|
||||
0x0941, 0x1B3C, 0x0062, 0x0371, 0x09AD, 0x08E8, 0x0A24, 0x0B97,
|
||||
0x1ED2, 0x0889, 0x136B, 0x0006, 0x1C4C, 0x0444, 0x06F8, 0x0DFB
|
||||
},
|
||||
|
||||
{
|
||||
0x1D0F, 0x198D, 0x0700, 0x0AFC, 0x1781, 0x12F3, 0x10DA, 0x1F19,
|
||||
0x1055, 0x0DC9, 0x1860, 0x012B, 0x05BF, 0x082D, 0x0C17, 0x1941
|
||||
},
|
||||
|
||||
{
|
||||
0x0359, 0x1232, 0x104C, 0x0762, 0x0897, 0x1D6C, 0x030F, 0x1A36,
|
||||
0x16B0, 0x094D, 0x1782, 0x036F, 0x0EEA, 0x06E6, 0x0D00, 0x0187
|
||||
},
|
||||
|
||||
{
|
||||
0x17E2, 0x05E5, 0x19FA, 0x1950, 0x146A, 0x0B2A, 0x0512, 0x0EE0,
|
||||
0x1E27, 0x112D, 0x1DF0, 0x0B13, 0x0378, 0x1DD0, 0x00C1, 0x01E6
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -0,0 +1,781 @@
|
|||
/*
|
||||
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
||||
** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
|
||||
**
|
||||
** This program is free software; you can redistribute it and/or modify
|
||||
** it under the terms of the GNU General Public License as published by
|
||||
** the Free Software Foundation; either version 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** This program is distributed in the hope that it will be useful,
|
||||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
** GNU General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program; if not, write to the Free Software
|
||||
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
**
|
||||
** Any non-GPL usage of this software or parts of this software is strictly
|
||||
** forbidden.
|
||||
**
|
||||
** Commercial non-GPL licensing of this software is possible.
|
||||
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
||||
**
|
||||
** $Id: mp4atom.c,v 1.17 2004/01/11 15:52:18 menno Exp $
|
||||
**/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "mp4ffint.h"
|
||||
|
||||
#include "drms.h"
|
||||
|
||||
/* parse atom header size */
|
||||
static int32_t mp4ff_atom_get_size(const int8_t *data)
|
||||
{
|
||||
uint32_t result;
|
||||
uint32_t a, b, c, d;
|
||||
|
||||
a = (uint8_t)data[0];
|
||||
b = (uint8_t)data[1];
|
||||
c = (uint8_t)data[2];
|
||||
d = (uint8_t)data[3];
|
||||
|
||||
result = (a<<24) | (b<<16) | (c<<8) | d;
|
||||
//if (result > 0 && result < 8) result = 8;
|
||||
|
||||
return (int32_t)result;
|
||||
}
|
||||
|
||||
/* comnapre 2 atom names, returns 1 for equal, 0 for unequal */
|
||||
static int32_t mp4ff_atom_compare(const int8_t a1, const int8_t b1, const int8_t c1, const int8_t d1,
|
||||
const int8_t a2, const int8_t b2, const int8_t c2, const int8_t d2)
|
||||
{
|
||||
if (a1 == a2 && b1 == b2 && c1 == c2 && d1 == d2)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint8_t mp4ff_atom_name_to_type(const int8_t a, const int8_t b,
|
||||
const int8_t c, const int8_t d)
|
||||
{
|
||||
if (a == 'm')
|
||||
{
|
||||
if (mp4ff_atom_compare(a,b,c,d, 'm','o','o','v'))
|
||||
return ATOM_MOOV;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','i','n','f'))
|
||||
return ATOM_MINF;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','d','i','a'))
|
||||
return ATOM_MDIA;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','d','a','t'))
|
||||
return ATOM_MDAT;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','d','h','d'))
|
||||
return ATOM_MDHD;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','v','h','d'))
|
||||
return ATOM_MVHD;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','p','4','a'))
|
||||
return ATOM_MP4A;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','p','4','v'))
|
||||
return ATOM_MP4V;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','p','4','s'))
|
||||
return ATOM_MP4S;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'm','e','t','a'))
|
||||
return ATOM_META;
|
||||
} else if (a == 't') {
|
||||
if (mp4ff_atom_compare(a,b,c,d, 't','r','a','k'))
|
||||
return ATOM_TRAK;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 't','k','h','d'))
|
||||
return ATOM_TKHD;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 't','r','e','f'))
|
||||
return ATOM_TREF;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 't','r','k','n'))
|
||||
return ATOM_TRACK;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 't','m','p','o'))
|
||||
return ATOM_TEMPO;
|
||||
} else if (a == 's') {
|
||||
if (mp4ff_atom_compare(a,b,c,d, 's','t','b','l'))
|
||||
return ATOM_STBL;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','m','h','d'))
|
||||
return ATOM_SMHD;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','t','s','d'))
|
||||
return ATOM_STSD;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','t','t','s'))
|
||||
return ATOM_STTS;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','t','c','o'))
|
||||
return ATOM_STCO;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','t','s','c'))
|
||||
return ATOM_STSC;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','t','s','z'))
|
||||
return ATOM_STSZ;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','t','z','2'))
|
||||
return ATOM_STZ2;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','k','i','p'))
|
||||
return ATOM_SKIP;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','i','n','f'))
|
||||
return ATOM_SINF;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 's','c','h','i'))
|
||||
return ATOM_SCHI;
|
||||
} else if (a == '©') {
|
||||
if (mp4ff_atom_compare(a,b,c,d, '©','n','a','m'))
|
||||
return ATOM_TITLE;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, '©','A','R','T'))
|
||||
return ATOM_ARTIST;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, '©','w','r','t'))
|
||||
return ATOM_WRITER;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, '©','a','l','b'))
|
||||
return ATOM_ALBUM;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, '©','d','a','y'))
|
||||
return ATOM_DATE;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, '©','t','o','o'))
|
||||
return ATOM_TOOL;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, '©','c','m','t'))
|
||||
return ATOM_COMMENT;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, '©','g','e','n'))
|
||||
return ATOM_GENRE1;
|
||||
}
|
||||
|
||||
if (mp4ff_atom_compare(a,b,c,d, 'e','d','t','s'))
|
||||
return ATOM_EDTS;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'e','s','d','s'))
|
||||
return ATOM_ESDS;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'f','t','y','p'))
|
||||
return ATOM_FTYP;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'f','r','e','e'))
|
||||
return ATOM_FREE;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'h','m','h','d'))
|
||||
return ATOM_HMHD;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'v','m','h','d'))
|
||||
return ATOM_VMHD;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'u','d','t','a'))
|
||||
return ATOM_UDTA;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'i','l','s','t'))
|
||||
return ATOM_ILST;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'n','a','m','e'))
|
||||
return ATOM_NAME;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'd','a','t','a'))
|
||||
return ATOM_DATA;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'd','i','s','k'))
|
||||
return ATOM_DISC;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'g','n','r','e'))
|
||||
return ATOM_GENRE2;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'c','o','v','r'))
|
||||
return ATOM_COVER;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'c','p','i','l'))
|
||||
return ATOM_COMPILATION;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'c','t','t','s'))
|
||||
return ATOM_CTTS;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'd','r','m','s'))
|
||||
return ATOM_DRMS;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'f','r','m','a'))
|
||||
return ATOM_FRMA;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'p','r','i','v'))
|
||||
return ATOM_PRIV;
|
||||
else if (mp4ff_atom_compare(a,b,c,d, 'i','v','i','v'))
|
||||
return ATOM_IVIV;
|
||||
else
|
||||
return ATOM_UNKNOWN;
|
||||
}
|
||||
|
||||
/* read atom header, return atom size, atom size is with header included */
|
||||
uint64_t mp4ff_atom_read_header(mp4ff_t *f, uint8_t *atom_type, uint8_t *header_size)
|
||||
{
|
||||
uint64_t size;
|
||||
int32_t ret;
|
||||
int8_t atom_header[8];
|
||||
|
||||
ret = mp4ff_read_data(f, atom_header, 8);
|
||||
if (ret != 8)
|
||||
return 0;
|
||||
|
||||
size = mp4ff_atom_get_size(atom_header);
|
||||
*header_size = 8;
|
||||
|
||||
/* check for 64 bit atom size */
|
||||
if (size == 1)
|
||||
{
|
||||
*header_size = 16;
|
||||
size = mp4ff_read_int64(f);
|
||||
}
|
||||
|
||||
//printf("%c%c%c%c\n", atom_header[4], atom_header[5], atom_header[6], atom_header[7]);
|
||||
|
||||
*atom_type = mp4ff_atom_name_to_type(atom_header[4], atom_header[5], atom_header[6], atom_header[7]);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_stsz(mp4ff_t *f)
|
||||
{
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
f->track[f->total_tracks - 1]->stsz_sample_size = mp4ff_read_int32(f);
|
||||
f->track[f->total_tracks - 1]->stsz_sample_count = mp4ff_read_int32(f);
|
||||
|
||||
if (f->track[f->total_tracks - 1]->stsz_sample_size == 0)
|
||||
{
|
||||
int32_t i;
|
||||
f->track[f->total_tracks - 1]->stsz_table =
|
||||
(int32_t*)malloc(f->track[f->total_tracks - 1]->stsz_sample_count*sizeof(int32_t));
|
||||
|
||||
for (i = 0; i < f->track[f->total_tracks - 1]->stsz_sample_count; i++)
|
||||
{
|
||||
f->track[f->total_tracks - 1]->stsz_table[i] = mp4ff_read_int32(f);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_esds(mp4ff_t *f)
|
||||
{
|
||||
uint8_t tag;
|
||||
uint32_t temp;
|
||||
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
|
||||
/* get and verify ES_DescrTag */
|
||||
tag = mp4ff_read_char(f);
|
||||
if (tag == 0x03)
|
||||
{
|
||||
/* read length */
|
||||
if (mp4ff_read_mp4_descr_length(f) < 5 + 15)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
/* skip 3 bytes */
|
||||
mp4ff_read_int24(f);
|
||||
} else {
|
||||
/* skip 2 bytes */
|
||||
mp4ff_read_int16(f);
|
||||
}
|
||||
|
||||
/* get and verify DecoderConfigDescrTab */
|
||||
if (mp4ff_read_char(f) != 0x04)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* read length */
|
||||
temp = mp4ff_read_mp4_descr_length(f);
|
||||
if (temp < 13) return 1;
|
||||
|
||||
f->track[f->total_tracks - 1]->audioType = mp4ff_read_char(f);
|
||||
mp4ff_read_int32(f);//0x15000414 ????
|
||||
f->track[f->total_tracks - 1]->maxBitrate = mp4ff_read_int32(f);
|
||||
f->track[f->total_tracks - 1]->avgBitrate = mp4ff_read_int32(f);
|
||||
|
||||
/* get and verify DecSpecificInfoTag */
|
||||
if (mp4ff_read_char(f) != 0x05)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* read length */
|
||||
f->track[f->total_tracks - 1]->decoderConfigLen = mp4ff_read_mp4_descr_length(f);
|
||||
|
||||
if (f->track[f->total_tracks - 1]->decoderConfig)
|
||||
free(f->track[f->total_tracks - 1]->decoderConfig);
|
||||
f->track[f->total_tracks - 1]->decoderConfig = malloc(f->track[f->total_tracks - 1]->decoderConfigLen);
|
||||
if (f->track[f->total_tracks - 1]->decoderConfig)
|
||||
{
|
||||
mp4ff_read_data(f, f->track[f->total_tracks - 1]->decoderConfig, f->track[f->total_tracks - 1]->decoderConfigLen);
|
||||
} else {
|
||||
f->track[f->total_tracks - 1]->decoderConfigLen = 0;
|
||||
}
|
||||
|
||||
/* will skip the remainder of the atom */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_mp4a(mp4ff_t *f)
|
||||
{
|
||||
uint64_t size;
|
||||
int32_t i;
|
||||
uint8_t atom_type = 0;
|
||||
uint8_t header_size = 0;
|
||||
|
||||
for (i = 0; i < 6; i++)
|
||||
{
|
||||
mp4ff_read_char(f); /* reserved */
|
||||
}
|
||||
/* data_reference_index */ mp4ff_read_int16(f);
|
||||
|
||||
mp4ff_read_int32(f); /* reserved */
|
||||
mp4ff_read_int32(f); /* reserved */
|
||||
|
||||
f->track[f->total_tracks - 1]->channelCount = mp4ff_read_int16(f);
|
||||
f->track[f->total_tracks - 1]->sampleSize = mp4ff_read_int16(f);
|
||||
|
||||
mp4ff_read_int16(f);
|
||||
mp4ff_read_int16(f);
|
||||
|
||||
f->track[f->total_tracks - 1]->sampleRate = mp4ff_read_int16(f);
|
||||
|
||||
mp4ff_read_int16(f);
|
||||
|
||||
size = mp4ff_atom_read_header(f, &atom_type, &header_size);
|
||||
if (atom_type == ATOM_ESDS)
|
||||
{
|
||||
mp4ff_read_esds(f);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef ITUNES_DRM
|
||||
static int32_t mp4ff_read_drms(mp4ff_t *f, uint64_t skip)
|
||||
{
|
||||
uint64_t size;
|
||||
int32_t i;
|
||||
uint8_t atom_type = 0;
|
||||
uint8_t header_size = 0;
|
||||
uint32_t drms_user_key[4];
|
||||
|
||||
if (drms_get_user_key(NULL, drms_user_key) == 0)
|
||||
{
|
||||
f->track[f->total_tracks - 1]->p_drms = drms_alloc();
|
||||
|
||||
drms_init( f->track[f->total_tracks - 1]->p_drms,
|
||||
DRMS_INIT_UKEY, (uint8_t *)drms_user_key,
|
||||
sizeof(drms_user_key) );
|
||||
}
|
||||
|
||||
for (i = 0; i < 6; i++)
|
||||
{
|
||||
mp4ff_read_char(f); /* reserved */
|
||||
}
|
||||
/* data_reference_index */ mp4ff_read_int16(f);
|
||||
|
||||
mp4ff_read_int32(f); /* reserved */
|
||||
mp4ff_read_int32(f); /* reserved */
|
||||
|
||||
f->track[f->total_tracks - 1]->channelCount = mp4ff_read_int16(f);
|
||||
f->track[f->total_tracks - 1]->sampleSize = mp4ff_read_int16(f);
|
||||
|
||||
mp4ff_read_int16(f);
|
||||
mp4ff_read_int16(f);
|
||||
|
||||
f->track[f->total_tracks - 1]->sampleRate = mp4ff_read_int16(f);
|
||||
|
||||
mp4ff_read_int16(f);
|
||||
|
||||
size = mp4ff_atom_read_header(f, &atom_type, &header_size);
|
||||
if (atom_type == ATOM_ESDS)
|
||||
{
|
||||
mp4ff_read_esds(f);
|
||||
}
|
||||
mp4ff_set_position(f, skip+size+28);
|
||||
|
||||
size = mp4ff_atom_read_header(f, &atom_type, &header_size);
|
||||
if (atom_type == ATOM_SINF)
|
||||
{
|
||||
parse_sub_atoms(f, size-header_size);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_frma(mp4ff_t *f)
|
||||
{
|
||||
uint8_t atom_type;
|
||||
int8_t type[4];
|
||||
|
||||
mp4ff_read_data(f, type, 4);
|
||||
|
||||
atom_type = mp4ff_atom_name_to_type(type[0], type[1], type[2], type[3]);
|
||||
|
||||
if (atom_type == ATOM_MP4A)
|
||||
{
|
||||
f->track[f->total_tracks - 1]->type = TRACK_AUDIO;
|
||||
} else if (atom_type == ATOM_MP4V) {
|
||||
f->track[f->total_tracks - 1]->type = TRACK_VIDEO;
|
||||
} else if (atom_type == ATOM_MP4S) {
|
||||
f->track[f->total_tracks - 1]->type = TRACK_SYSTEM;
|
||||
} else {
|
||||
f->track[f->total_tracks - 1]->type = TRACK_UNKNOWN;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_name(mp4ff_t *f, uint64_t size)
|
||||
{
|
||||
uint8_t *data = malloc(size);
|
||||
mp4ff_read_data(f, data, size);
|
||||
|
||||
if (f->track[f->total_tracks - 1]->p_drms != NULL)
|
||||
{
|
||||
drms_init(f->track[f->total_tracks - 1]->p_drms,
|
||||
DRMS_INIT_NAME, data, strlen(data) );
|
||||
}
|
||||
|
||||
if (data)
|
||||
free(data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_priv(mp4ff_t *f, uint64_t size)
|
||||
{
|
||||
uint8_t *data = malloc(size);
|
||||
mp4ff_read_data(f, data, size);
|
||||
|
||||
if (f->track[f->total_tracks - 1]->p_drms != 0)
|
||||
{
|
||||
drms_init(f->track[f->total_tracks - 1]->p_drms,
|
||||
DRMS_INIT_PRIV, data, size );
|
||||
}
|
||||
|
||||
if (data)
|
||||
free(data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_iviv(mp4ff_t *f, uint64_t size)
|
||||
{
|
||||
uint8_t *data = malloc(size);
|
||||
mp4ff_read_data(f, data, size);
|
||||
|
||||
if (f->track[f->total_tracks - 1]->p_drms != 0)
|
||||
{
|
||||
drms_init(f->track[f->total_tracks - 1]->p_drms,
|
||||
DRMS_INIT_IVIV, data, sizeof(uint32_t) * 4 );
|
||||
}
|
||||
|
||||
if (data)
|
||||
free(data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int32_t mp4ff_read_stsd(mp4ff_t *f)
|
||||
{
|
||||
int32_t i;
|
||||
uint8_t header_size = 0;
|
||||
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
|
||||
f->track[f->total_tracks - 1]->stsd_entry_count = mp4ff_read_int32(f);
|
||||
|
||||
for (i = 0; i < f->track[f->total_tracks - 1]->stsd_entry_count; i++)
|
||||
{
|
||||
uint64_t skip = mp4ff_position(f);
|
||||
uint64_t size;
|
||||
uint8_t atom_type = 0;
|
||||
size = mp4ff_atom_read_header(f, &atom_type, &header_size);
|
||||
skip += size;
|
||||
|
||||
if (atom_type == ATOM_MP4A)
|
||||
{
|
||||
f->track[f->total_tracks - 1]->type = TRACK_AUDIO;
|
||||
mp4ff_read_mp4a(f);
|
||||
} else if (atom_type == ATOM_MP4V) {
|
||||
f->track[f->total_tracks - 1]->type = TRACK_VIDEO;
|
||||
} else if (atom_type == ATOM_MP4S) {
|
||||
f->track[f->total_tracks - 1]->type = TRACK_SYSTEM;
|
||||
#ifdef ITUNES_DRM
|
||||
} else if (atom_type == ATOM_DRMS) {
|
||||
// track type is read from the "frma" atom
|
||||
f->track[f->total_tracks - 1]->type = TRACK_UNKNOWN;
|
||||
mp4ff_read_drms(f, skip-size+header_size);
|
||||
#endif
|
||||
} else {
|
||||
f->track[f->total_tracks - 1]->type = TRACK_UNKNOWN;
|
||||
}
|
||||
|
||||
mp4ff_set_position(f, skip);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_stsc(mp4ff_t *f)
|
||||
{
|
||||
int32_t i;
|
||||
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
f->track[f->total_tracks - 1]->stsc_entry_count = mp4ff_read_int32(f);
|
||||
|
||||
f->track[f->total_tracks - 1]->stsc_first_chunk =
|
||||
(int32_t*)malloc(f->track[f->total_tracks - 1]->stsc_entry_count*sizeof(int32_t));
|
||||
f->track[f->total_tracks - 1]->stsc_samples_per_chunk =
|
||||
(int32_t*)malloc(f->track[f->total_tracks - 1]->stsc_entry_count*sizeof(int32_t));
|
||||
f->track[f->total_tracks - 1]->stsc_sample_desc_index =
|
||||
(int32_t*)malloc(f->track[f->total_tracks - 1]->stsc_entry_count*sizeof(int32_t));
|
||||
|
||||
for (i = 0; i < f->track[f->total_tracks - 1]->stsc_entry_count; i++)
|
||||
{
|
||||
f->track[f->total_tracks - 1]->stsc_first_chunk[i] = mp4ff_read_int32(f);
|
||||
f->track[f->total_tracks - 1]->stsc_samples_per_chunk[i] = mp4ff_read_int32(f);
|
||||
f->track[f->total_tracks - 1]->stsc_sample_desc_index[i] = mp4ff_read_int32(f);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_stco(mp4ff_t *f)
|
||||
{
|
||||
int32_t i;
|
||||
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
f->track[f->total_tracks - 1]->stco_entry_count = mp4ff_read_int32(f);
|
||||
|
||||
f->track[f->total_tracks - 1]->stco_chunk_offset =
|
||||
(int32_t*)malloc(f->track[f->total_tracks - 1]->stco_entry_count*sizeof(int32_t));
|
||||
|
||||
for (i = 0; i < f->track[f->total_tracks - 1]->stco_entry_count; i++)
|
||||
{
|
||||
f->track[f->total_tracks - 1]->stco_chunk_offset[i] = mp4ff_read_int32(f);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_ctts(mp4ff_t *f)
|
||||
{
|
||||
int32_t i;
|
||||
mp4ff_track_t * p_track = f->track[f->total_tracks - 1];
|
||||
|
||||
if (p_track->ctts_entry_count) return 0;
|
||||
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
p_track->ctts_entry_count = mp4ff_read_int32(f);
|
||||
|
||||
p_track->ctts_sample_count = (int32_t*)malloc(p_track->ctts_entry_count * sizeof(int32_t));
|
||||
p_track->ctts_sample_offset = (int32_t*)malloc(p_track->ctts_entry_count * sizeof(int32_t));
|
||||
|
||||
if (p_track->ctts_sample_count == 0 || p_track->ctts_sample_offset == 0)
|
||||
{
|
||||
if (p_track->ctts_sample_count) {free(p_track->ctts_sample_count);p_track->ctts_sample_count=0;}
|
||||
if (p_track->ctts_sample_offset) {free(p_track->ctts_sample_offset);p_track->ctts_sample_offset=0;}
|
||||
p_track->ctts_entry_count = 0;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < f->track[f->total_tracks - 1]->ctts_entry_count; i++)
|
||||
{
|
||||
p_track->ctts_sample_count[i] = mp4ff_read_int32(f);
|
||||
p_track->ctts_sample_offset[i] = mp4ff_read_int32(f);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_stts(mp4ff_t *f)
|
||||
{
|
||||
int32_t i;
|
||||
mp4ff_track_t * p_track = f->track[f->total_tracks - 1];
|
||||
|
||||
if (p_track->stts_entry_count) return 0;
|
||||
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
p_track->stts_entry_count = mp4ff_read_int32(f);
|
||||
|
||||
p_track->stts_sample_count = (int32_t*)malloc(p_track->stts_entry_count * sizeof(int32_t));
|
||||
p_track->stts_sample_delta = (int32_t*)malloc(p_track->stts_entry_count * sizeof(int32_t));
|
||||
|
||||
if (p_track->stts_sample_count == 0 || p_track->stts_sample_delta == 0)
|
||||
{
|
||||
if (p_track->stts_sample_count) {free(p_track->stts_sample_count);p_track->stts_sample_count=0;}
|
||||
if (p_track->stts_sample_delta) {free(p_track->stts_sample_delta);p_track->stts_sample_delta=0;}
|
||||
p_track->stts_entry_count = 0;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < f->track[f->total_tracks - 1]->stts_entry_count; i++)
|
||||
{
|
||||
p_track->stts_sample_count[i] = mp4ff_read_int32(f);
|
||||
p_track->stts_sample_delta[i] = mp4ff_read_int32(f);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
static int32_t mp4ff_read_mvhd(mp4ff_t *f)
|
||||
{
|
||||
int32_t i;
|
||||
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
/* creation_time */ mp4ff_read_int32(f);
|
||||
/* modification_time */ mp4ff_read_int32(f);
|
||||
f->time_scale = mp4ff_read_int32(f);
|
||||
f->duration = mp4ff_read_int32(f);
|
||||
/* preferred_rate */ mp4ff_read_int32(f); /*mp4ff_read_fixed32(f);*/
|
||||
/* preferred_volume */ mp4ff_read_int16(f); /*mp4ff_read_fixed16(f);*/
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
/* reserved */ mp4ff_read_char(f);
|
||||
}
|
||||
for (i = 0; i < 9; i++)
|
||||
{
|
||||
mp4ff_read_int32(f); /* matrix */
|
||||
}
|
||||
/* preview_time */ mp4ff_read_int32(f);
|
||||
/* preview_duration */ mp4ff_read_int32(f);
|
||||
/* poster_time */ mp4ff_read_int32(f);
|
||||
/* selection_time */ mp4ff_read_int32(f);
|
||||
/* selection_duration */ mp4ff_read_int32(f);
|
||||
/* current_time */ mp4ff_read_int32(f);
|
||||
/* next_track_id */ mp4ff_read_int32(f);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static int32_t mp4ff_read_tkhd(mp4ff_t *f)
|
||||
{
|
||||
uint8_t version;
|
||||
uint32_t flags;
|
||||
version = mp4ff_read_char(f); /* version */
|
||||
flags = mp4ff_read_int24(f); /* flags */
|
||||
if (version==1)
|
||||
{
|
||||
mp4ff_read_int64(f);//creation-time
|
||||
mp4ff_read_int64(f);//modification-time
|
||||
mp4ff_read_int32(f);//track-id
|
||||
mp4ff_read_int32(f);//reserved
|
||||
f->track[f->total_tracks - 1]->duration = mp4ff_read_int64(f);//duration
|
||||
}
|
||||
else //version == 0
|
||||
{
|
||||
mp4ff_read_int32(f);//creation-time
|
||||
mp4ff_read_int32(f);//modification-time
|
||||
mp4ff_read_int32(f);//track-id
|
||||
mp4ff_read_int32(f);//reserved
|
||||
f->track[f->total_tracks - 1]->duration = mp4ff_read_int32(f);//duration
|
||||
if (f->track[f->total_tracks - 1]->duration == 0xFFFFFFFF)
|
||||
f->track[f->total_tracks - 1]->duration = 0xFFFFFFFFFFFFFFFF;
|
||||
|
||||
}
|
||||
mp4ff_read_int32(f);//reserved
|
||||
mp4ff_read_int32(f);//reserved
|
||||
mp4ff_read_int16(f);//layer
|
||||
mp4ff_read_int16(f);//pre-defined
|
||||
mp4ff_read_int16(f);//volume
|
||||
mp4ff_read_int16(f);//reserved
|
||||
|
||||
//matrix
|
||||
mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);
|
||||
mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);
|
||||
mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);
|
||||
mp4ff_read_int32(f);//width
|
||||
mp4ff_read_int32(f);//height
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int32_t mp4ff_read_mdhd(mp4ff_t *f)
|
||||
{
|
||||
uint32_t version;
|
||||
|
||||
version = mp4ff_read_int32(f);
|
||||
if (version==1)
|
||||
{
|
||||
mp4ff_read_int64(f);//creation-time
|
||||
mp4ff_read_int64(f);//modification-time
|
||||
f->track[f->total_tracks - 1]->timeScale = mp4ff_read_int32(f);//timescale
|
||||
f->track[f->total_tracks - 1]->duration = mp4ff_read_int64(f);//duration
|
||||
}
|
||||
else //version == 0
|
||||
{
|
||||
uint32_t temp;
|
||||
|
||||
mp4ff_read_int32(f);//creation-time
|
||||
mp4ff_read_int32(f);//modification-time
|
||||
f->track[f->total_tracks - 1]->timeScale = mp4ff_read_int32(f);//timescale
|
||||
temp = mp4ff_read_int32(f);
|
||||
f->track[f->total_tracks - 1]->duration = (temp == (uint32_t)(-1)) ? (uint64_t)(-1) : (uint64_t)(temp);
|
||||
}
|
||||
mp4ff_read_int16(f);
|
||||
mp4ff_read_int16(f);
|
||||
return 1;
|
||||
}
|
||||
#ifdef USE_TAGGING
|
||||
static int32_t mp4ff_read_meta(mp4ff_t *f, const uint64_t size)
|
||||
{
|
||||
uint64_t subsize, sumsize = 0;
|
||||
uint8_t atom_type;
|
||||
uint8_t header_size = 0;
|
||||
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
|
||||
while (sumsize < (size-12))
|
||||
{
|
||||
subsize = mp4ff_atom_read_header(f, &atom_type, &header_size);
|
||||
if (atom_type == ATOM_ILST)
|
||||
{
|
||||
mp4ff_parse_metadata(f, (uint32_t)(subsize-(header_size+4)));
|
||||
} else {
|
||||
mp4ff_set_position(f, mp4ff_position(f)+subsize-header_size);
|
||||
}
|
||||
sumsize += subsize;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
int32_t mp4ff_atom_read(mp4ff_t *f, const int32_t size, const uint8_t atom_type)
|
||||
{
|
||||
uint64_t dest_position = mp4ff_position(f)+size-8;
|
||||
if (atom_type == ATOM_STSZ)
|
||||
{
|
||||
/* sample size box */
|
||||
mp4ff_read_stsz(f);
|
||||
} else if (atom_type == ATOM_STTS) {
|
||||
/* time to sample box */
|
||||
mp4ff_read_stts(f);
|
||||
} else if (atom_type == ATOM_CTTS) {
|
||||
/* composition offset box */
|
||||
mp4ff_read_ctts(f);
|
||||
} else if (atom_type == ATOM_STSC) {
|
||||
/* sample to chunk box */
|
||||
mp4ff_read_stsc(f);
|
||||
} else if (atom_type == ATOM_STCO) {
|
||||
/* chunk offset box */
|
||||
mp4ff_read_stco(f);
|
||||
} else if (atom_type == ATOM_STSD) {
|
||||
/* sample description box */
|
||||
mp4ff_read_stsd(f);
|
||||
} else if (atom_type == ATOM_MVHD) {
|
||||
/* movie header box */
|
||||
mp4ff_read_mvhd(f);
|
||||
} else if (atom_type == ATOM_MDHD) {
|
||||
/* track header */
|
||||
mp4ff_read_mdhd(f);
|
||||
#ifdef ITUNES_DRM
|
||||
} else if (atom_type == ATOM_FRMA) {
|
||||
/* DRM track format */
|
||||
mp4ff_read_frma(f);
|
||||
} else if (atom_type == ATOM_IVIV) {
|
||||
mp4ff_read_iviv(f, size-8);
|
||||
} else if (atom_type == ATOM_NAME) {
|
||||
mp4ff_read_name(f, size-8);
|
||||
} else if (atom_type == ATOM_PRIV) {
|
||||
mp4ff_read_priv(f, size-8);
|
||||
#endif
|
||||
#ifdef USE_TAGGING
|
||||
} else if (atom_type == ATOM_META) {
|
||||
/* iTunes Metadata box */
|
||||
mp4ff_read_meta(f, size);
|
||||
#endif
|
||||
}
|
||||
|
||||
mp4ff_set_position(f, dest_position);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,428 @@
|
|||
/*
|
||||
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
||||
** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
|
||||
**
|
||||
** This program is free software; you can redistribute it and/or modify
|
||||
** it under the terms of the GNU General Public License as published by
|
||||
** the Free Software Foundation; either version 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** This program is distributed in the hope that it will be useful,
|
||||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
** GNU General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program; if not, write to the Free Software
|
||||
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
**
|
||||
** Any non-GPL usage of this software or parts of this software is strictly
|
||||
** forbidden.
|
||||
**
|
||||
** Commercial non-GPL licensing of this software is possible.
|
||||
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
||||
**
|
||||
** $Id: mp4ff.c,v 1.15 2004/01/11 15:52:18 menno Exp $
|
||||
**/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "mp4ffint.h"
|
||||
|
||||
#include "drms.h"
|
||||
|
||||
mp4ff_t *mp4ff_open_read(mp4ff_callback_t *f)
|
||||
{
|
||||
mp4ff_t *ff = malloc(sizeof(mp4ff_t));
|
||||
|
||||
memset(ff, 0, sizeof(mp4ff_t));
|
||||
|
||||
ff->stream = f;
|
||||
|
||||
parse_atoms(ff);
|
||||
|
||||
return ff;
|
||||
}
|
||||
|
||||
void mp4ff_close(mp4ff_t *ff)
|
||||
{
|
||||
int32_t i;
|
||||
|
||||
for (i = 0; i < ff->total_tracks; i++)
|
||||
{
|
||||
if (ff->track[i])
|
||||
{
|
||||
if (ff->track[i]->stsz_table)
|
||||
free(ff->track[i]->stsz_table);
|
||||
if (ff->track[i]->stts_sample_count)
|
||||
free(ff->track[i]->stts_sample_count);
|
||||
if (ff->track[i]->stts_sample_delta)
|
||||
free(ff->track[i]->stts_sample_delta);
|
||||
if (ff->track[i]->stsc_first_chunk)
|
||||
free(ff->track[i]->stsc_first_chunk);
|
||||
if (ff->track[i]->stsc_samples_per_chunk)
|
||||
free(ff->track[i]->stsc_samples_per_chunk);
|
||||
if (ff->track[i]->stsc_sample_desc_index)
|
||||
free(ff->track[i]->stsc_sample_desc_index);
|
||||
if (ff->track[i]->stco_chunk_offset)
|
||||
free(ff->track[i]->stco_chunk_offset);
|
||||
if (ff->track[i]->decoderConfig)
|
||||
free(ff->track[i]->decoderConfig);
|
||||
if (ff->track[i]->ctts_sample_count)
|
||||
free(ff->track[i]->ctts_sample_count);
|
||||
if (ff->track[i]->ctts_sample_offset)
|
||||
free(ff->track[i]->ctts_sample_offset);
|
||||
#ifdef ITUNES_DRM
|
||||
if (ff->track[i]->p_drms)
|
||||
drms_free(ff->track[i]->p_drms);
|
||||
#endif
|
||||
free(ff->track[i]);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef USE_TAGGING
|
||||
mp4ff_tag_delete(&(ff->tags));
|
||||
#endif
|
||||
|
||||
if (ff) free(ff);
|
||||
}
|
||||
|
||||
static void mp4ff_track_add(mp4ff_t *f)
|
||||
{
|
||||
f->total_tracks++;
|
||||
|
||||
f->track[f->total_tracks - 1] = malloc(sizeof(mp4ff_track_t));
|
||||
|
||||
memset(f->track[f->total_tracks - 1], 0, sizeof(mp4ff_track_t));
|
||||
}
|
||||
|
||||
/* parse atoms that are sub atoms of other atoms */
|
||||
int32_t parse_sub_atoms(mp4ff_t *f, const uint64_t total_size)
|
||||
{
|
||||
uint64_t size;
|
||||
uint8_t atom_type = 0;
|
||||
uint64_t counted_size = 0;
|
||||
uint8_t header_size = 0;
|
||||
|
||||
while (counted_size < total_size)
|
||||
{
|
||||
size = mp4ff_atom_read_header(f, &atom_type, &header_size);
|
||||
counted_size += size;
|
||||
|
||||
/* check for end of file */
|
||||
if (size == 0)
|
||||
break;
|
||||
|
||||
/* we're starting to read a new track, update index,
|
||||
* so that all data and tables get written in the right place
|
||||
*/
|
||||
if (atom_type == ATOM_TRAK)
|
||||
{
|
||||
mp4ff_track_add(f);
|
||||
}
|
||||
|
||||
/* parse subatoms */
|
||||
if (atom_type < SUBATOMIC)
|
||||
{
|
||||
parse_sub_atoms(f, size-header_size);
|
||||
} else {
|
||||
mp4ff_atom_read(f, (uint32_t)size, atom_type);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* parse root atoms */
|
||||
int32_t parse_atoms(mp4ff_t *f)
|
||||
{
|
||||
uint64_t size;
|
||||
uint8_t atom_type = 0;
|
||||
uint8_t header_size = 0;
|
||||
|
||||
f->file_size = 0;
|
||||
|
||||
while ((size = mp4ff_atom_read_header(f, &atom_type, &header_size)) != 0)
|
||||
{
|
||||
f->file_size += size;
|
||||
f->last_atom = atom_type;
|
||||
|
||||
if (atom_type == ATOM_MDAT && f->moov_read)
|
||||
{
|
||||
/* moov atom is before mdat, we can stop reading when mdat is encountered */
|
||||
/* file position will stay at beginning of mdat data */
|
||||
// break;
|
||||
}
|
||||
|
||||
if (atom_type == ATOM_MOOV && size > header_size)
|
||||
{
|
||||
f->moov_read = 1;
|
||||
f->moov_offset = mp4ff_position(f)-header_size;
|
||||
f->moov_size = size;
|
||||
}
|
||||
|
||||
/* parse subatoms */
|
||||
if (atom_type < SUBATOMIC)
|
||||
{
|
||||
parse_sub_atoms(f, size-header_size);
|
||||
} else {
|
||||
/* skip this atom */
|
||||
mp4ff_set_position(f, mp4ff_position(f)+size-header_size);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t mp4ff_get_decoder_config(const mp4ff_t *f, const int32_t track,
|
||||
uint8_t** ppBuf, uint32_t* pBufSize)
|
||||
{
|
||||
if (track >= f->total_tracks)
|
||||
{
|
||||
*ppBuf = NULL;
|
||||
*pBufSize = 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (f->track[track]->decoderConfig == NULL || f->track[track]->decoderConfigLen == 0)
|
||||
{
|
||||
*ppBuf = NULL;
|
||||
*pBufSize = 0;
|
||||
} else {
|
||||
*ppBuf = malloc(f->track[track]->decoderConfigLen);
|
||||
if (*ppBuf == NULL)
|
||||
{
|
||||
*pBufSize = 0;
|
||||
return 1;
|
||||
}
|
||||
memcpy(*ppBuf, f->track[track]->decoderConfig, f->track[track]->decoderConfigLen);
|
||||
*pBufSize = f->track[track]->decoderConfigLen;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t mp4ff_get_track_type(const mp4ff_t *f, const int track)
|
||||
{
|
||||
return f->track[track]->type;
|
||||
}
|
||||
|
||||
int32_t mp4ff_total_tracks(const mp4ff_t *f)
|
||||
{
|
||||
return f->total_tracks;
|
||||
}
|
||||
|
||||
int32_t mp4ff_time_scale(const mp4ff_t *f, const int32_t track)
|
||||
{
|
||||
return f->track[track]->timeScale;
|
||||
}
|
||||
|
||||
uint32_t mp4ff_get_avg_bitrate(const mp4ff_t *f, const int32_t track)
|
||||
{
|
||||
return f->track[track]->avgBitrate;
|
||||
}
|
||||
|
||||
uint32_t mp4ff_get_max_bitrate(const mp4ff_t *f, const int32_t track)
|
||||
{
|
||||
return f->track[track]->maxBitrate;
|
||||
}
|
||||
|
||||
int64_t mp4ff_get_track_duration(const mp4ff_t *f, const int32_t track)
|
||||
{
|
||||
return f->track[track]->duration;
|
||||
}
|
||||
|
||||
int64_t mp4ff_get_track_duration_use_offsets(const mp4ff_t *f, const int32_t track)
|
||||
{
|
||||
int64_t duration = mp4ff_get_track_duration(f,track);
|
||||
if (duration!=-1)
|
||||
{
|
||||
int64_t offset = mp4ff_get_sample_offset(f,track,0);
|
||||
if (offset > duration) duration = 0;
|
||||
else duration -= offset;
|
||||
}
|
||||
return duration;
|
||||
}
|
||||
|
||||
|
||||
int32_t mp4ff_num_samples(const mp4ff_t *f, const int32_t track)
|
||||
{
|
||||
int32_t i;
|
||||
int32_t total = 0;
|
||||
|
||||
for (i = 0; i < f->track[track]->stts_entry_count; i++)
|
||||
{
|
||||
total += f->track[track]->stts_sample_count[i];
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
uint32_t mp4ff_get_sample_rate(const mp4ff_t *f, const int32_t track)
|
||||
{
|
||||
return f->track[track]->sampleRate;
|
||||
}
|
||||
|
||||
uint32_t mp4ff_get_channel_count(const mp4ff_t * f,const int32_t track)
|
||||
{
|
||||
return f->track[track]->channelCount;
|
||||
}
|
||||
|
||||
uint32_t mp4ff_get_audio_type(const mp4ff_t * f,const int32_t track)
|
||||
{
|
||||
return f->track[track]->audioType;
|
||||
}
|
||||
|
||||
int32_t mp4ff_get_sample_duration_use_offsets(const mp4ff_t *f, const int32_t track, const int32_t sample)
|
||||
{
|
||||
int32_t d,o;
|
||||
d = mp4ff_get_sample_duration(f,track,sample);
|
||||
if (d!=-1)
|
||||
{
|
||||
o = mp4ff_get_sample_offset(f,track,sample);
|
||||
if (o>d) d = 0;
|
||||
else d -= o;
|
||||
}
|
||||
return d;
|
||||
}
|
||||
|
||||
int32_t mp4ff_get_sample_duration(const mp4ff_t *f, const int32_t track, const int32_t sample)
|
||||
{
|
||||
int32_t i, co = 0;
|
||||
|
||||
for (i = 0; i < f->track[track]->stts_entry_count; i++)
|
||||
{
|
||||
int32_t delta = f->track[track]->stts_sample_count[i];
|
||||
if (sample < co + delta)
|
||||
return f->track[track]->stts_sample_delta[i];
|
||||
co += delta;
|
||||
}
|
||||
return (int32_t)(-1);
|
||||
}
|
||||
|
||||
int64_t mp4ff_get_sample_position(const mp4ff_t *f, const int32_t track, const int32_t sample)
|
||||
{
|
||||
int32_t i, co = 0;
|
||||
int64_t acc = 0;
|
||||
|
||||
for (i = 0; i < f->track[track]->stts_entry_count; i++)
|
||||
{
|
||||
int32_t delta = f->track[track]->stts_sample_count[i];
|
||||
if (sample < co + delta)
|
||||
{
|
||||
acc += f->track[track]->stts_sample_delta[i] * (sample - co);
|
||||
return acc;
|
||||
}
|
||||
else
|
||||
{
|
||||
acc += f->track[track]->stts_sample_delta[i] * delta;
|
||||
}
|
||||
co += delta;
|
||||
}
|
||||
return (int64_t)(-1);
|
||||
}
|
||||
|
||||
int32_t mp4ff_get_sample_offset(const mp4ff_t *f, const int32_t track, const int32_t sample)
|
||||
{
|
||||
int32_t i, co = 0;
|
||||
|
||||
for (i = 0; i < f->track[track]->ctts_entry_count; i++)
|
||||
{
|
||||
int32_t delta = f->track[track]->ctts_sample_count[i];
|
||||
if (sample < co + delta)
|
||||
return f->track[track]->ctts_sample_offset[i];
|
||||
co += delta;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t mp4ff_find_sample(const mp4ff_t *f, const int32_t track, const int64_t offset,int32_t * toskip)
|
||||
{
|
||||
int32_t i, co = 0;
|
||||
int64_t offset_total = 0;
|
||||
mp4ff_track_t * p_track = f->track[track];
|
||||
|
||||
for (i = 0; i < p_track->stts_entry_count; i++)
|
||||
{
|
||||
int32_t sample_count = p_track->stts_sample_count[i];
|
||||
int32_t sample_delta = p_track->stts_sample_delta[i];
|
||||
int64_t offset_delta = (int64_t)sample_delta * (int64_t)sample_count;
|
||||
if (offset < offset_total + offset_delta)
|
||||
{
|
||||
int64_t offset_fromstts = offset - offset_total;
|
||||
if (toskip) *toskip = (int32_t)(offset_fromstts % sample_delta);
|
||||
return co + (int32_t)(offset_fromstts / sample_delta);
|
||||
}
|
||||
else
|
||||
{
|
||||
offset_total += offset_delta;
|
||||
}
|
||||
co += sample_count;
|
||||
}
|
||||
return (int32_t)(-1);
|
||||
}
|
||||
|
||||
int32_t mp4ff_find_sample_use_offsets(const mp4ff_t *f, const int32_t track, const int64_t offset,int32_t * toskip)
|
||||
{
|
||||
return mp4ff_find_sample(f,track,offset + mp4ff_get_sample_offset(f,track,0),toskip);
|
||||
}
|
||||
|
||||
int32_t mp4ff_read_sample(mp4ff_t *f, const int32_t track, const int32_t sample,
|
||||
uint8_t **audio_buffer, uint32_t *bytes)
|
||||
{
|
||||
int32_t result = 0;
|
||||
|
||||
*bytes = mp4ff_audio_frame_size(f, track, sample);
|
||||
|
||||
if (*bytes==0) return 0;
|
||||
|
||||
*audio_buffer = (uint8_t*)malloc(*bytes);
|
||||
|
||||
mp4ff_set_sample_position(f, track, sample);
|
||||
|
||||
result = mp4ff_read_data(f, *audio_buffer, *bytes);
|
||||
|
||||
if (!result)
|
||||
{
|
||||
free(*audio_buffer);
|
||||
*audio_buffer = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef ITUNES_DRM
|
||||
if (f->track[track]->p_drms != NULL)
|
||||
{
|
||||
drms_decrypt(f->track[track]->p_drms, (uint32_t*)*audio_buffer, *bytes);
|
||||
}
|
||||
#endif
|
||||
|
||||
return *bytes;
|
||||
}
|
||||
|
||||
|
||||
int32_t mp4ff_read_sample_v2(mp4ff_t *f, const int track, const int sample,unsigned char *buffer)
|
||||
{
|
||||
int32_t result = 0;
|
||||
int32_t size = mp4ff_audio_frame_size(f,track,sample);
|
||||
if (size<=0) return 0;
|
||||
mp4ff_set_sample_position(f, track, sample);
|
||||
result = mp4ff_read_data(f,buffer,size);
|
||||
|
||||
#ifdef ITUNES_DRM
|
||||
if (f->track[track]->p_drms != NULL)
|
||||
{
|
||||
drms_decrypt(f->track[track]->p_drms, (uint32_t*)buffer, size);
|
||||
}
|
||||
#endif
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int32_t mp4ff_read_sample_getsize(mp4ff_t *f, const int track, const int sample)
|
||||
{
|
||||
int32_t temp = mp4ff_audio_frame_size(f, track, sample);
|
||||
if (temp<0) temp = 0;
|
||||
return temp;
|
||||
}
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
# Microsoft Developer Studio Project File - Name="mp4ff" - Package Owner=<4>
|
||||
# Microsoft Developer Studio Generated Build File, Format Version 6.00
|
||||
# ** DO NOT EDIT **
|
||||
|
||||
# TARGTYPE "Win32 (x86) Static Library" 0x0104
|
||||
|
||||
CFG=mp4ff - Win32 Debug
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "mp4ff.mak".
|
||||
!MESSAGE
|
||||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "mp4ff.mak" CFG="mp4ff - Win32 Debug"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "mp4ff - Win32 Release" (based on "Win32 (x86) Static Library")
|
||||
!MESSAGE "mp4ff - Win32 Debug" (based on "Win32 (x86) Static Library")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
# PROP AllowPerConfigDependencies 0
|
||||
# PROP Scc_ProjName ""
|
||||
# PROP Scc_LocalPath ""
|
||||
CPP=xicl6.exe
|
||||
RSC=rc.exe
|
||||
|
||||
!IF "$(CFG)" == "mp4ff - Win32 Release"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "Release"
|
||||
# PROP BASE Intermediate_Dir "Release"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release"
|
||||
# PROP Intermediate_Dir "Release"
|
||||
# PROP Target_Dir ""
|
||||
F90=df.exe
|
||||
MTL=midl.exe
|
||||
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
|
||||
# ADD CPP /nologo /MD /W3 /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "USE_TAGGING" /YX /FD /c
|
||||
# ADD BASE RSC /l 0x413 /d "NDEBUG"
|
||||
# ADD RSC /l 0x413 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LIB32=xilink6.exe -lib
|
||||
# ADD BASE LIB32 /nologo
|
||||
# ADD LIB32 /nologo
|
||||
|
||||
!ELSEIF "$(CFG)" == "mp4ff - Win32 Debug"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "Debug"
|
||||
# PROP BASE Intermediate_Dir "Debug"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug"
|
||||
# PROP Intermediate_Dir "Debug"
|
||||
# PROP Target_Dir ""
|
||||
F90=df.exe
|
||||
MTL=midl.exe
|
||||
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
|
||||
# ADD CPP /nologo /MDd /W3 /Gm /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "USE_TAGGING" /YX /FD /GZ /c
|
||||
# ADD BASE RSC /l 0x413 /d "_DEBUG"
|
||||
# ADD RSC /l 0x413 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LIB32=xilink6.exe -lib
|
||||
# ADD BASE LIB32 /nologo
|
||||
# ADD LIB32 /nologo
|
||||
|
||||
!ENDIF
|
||||
|
||||
# Begin Target
|
||||
|
||||
# Name "mp4ff - Win32 Release"
|
||||
# Name "mp4ff - Win32 Debug"
|
||||
# Begin Group "Source Files"
|
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\drms.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4atom.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4ff.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4meta.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4sample.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4tagupdate.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4util.c
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Header Files"
|
||||
|
||||
# PROP Default_Filter "h;hpp;hxx;hm;inl"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\drms.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\drmstables.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4ff.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4ff_int_types.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mp4ffint.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# End Target
|
||||
# End Project
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
/*
|
||||
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
||||
** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
|
||||
**
|
||||
** This program is free software; you can redistribute it and/or modify
|
||||
** it under the terms of the GNU General Public License as published by
|
||||
** the Free Software Foundation; either version 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** This program is distributed in the hope that it will be useful,
|
||||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
** GNU General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program; if not, write to the Free Software
|
||||
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
**
|
||||
** Any non-GPL usage of this software or parts of this software is strictly
|
||||
** forbidden.
|
||||
**
|
||||
** Commercial non-GPL licensing of this software is possible.
|
||||
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
||||
**
|
||||
** $Id: mp4ff.h,v 1.19 2004/01/11 15:52:18 menno Exp $
|
||||
**/
|
||||
|
||||
#ifndef MP4FF_H
|
||||
#define MP4FF_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#include "mp4ff_int_types.h"
|
||||
|
||||
/* file callback structure */
|
||||
typedef struct
|
||||
{
|
||||
uint32_t (*read)(void *user_data, void *buffer, uint32_t length);
|
||||
uint32_t (*write)(void *udata, void *buffer, uint32_t length);
|
||||
uint32_t (*seek)(void *user_data, uint64_t position);
|
||||
uint32_t (*truncate)(void *user_data);
|
||||
void *user_data;
|
||||
} mp4ff_callback_t;
|
||||
|
||||
/* mp4 main file structure */
|
||||
typedef void* mp4ff_t;
|
||||
|
||||
|
||||
/* API */
|
||||
|
||||
mp4ff_t *mp4ff_open_read(mp4ff_callback_t *f);
|
||||
void mp4ff_close(mp4ff_t *f);
|
||||
int32_t mp4ff_get_sample_duration(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int32_t mp4ff_get_sample_duration_use_offsets(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int64_t mp4ff_get_sample_position(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int32_t mp4ff_get_sample_offset(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int32_t mp4ff_find_sample(const mp4ff_t *f, const int32_t track, const int64_t offset,int32_t * toskip);
|
||||
int32_t mp4ff_find_sample_use_offsets(const mp4ff_t *f, const int32_t track, const int64_t offset,int32_t * toskip);
|
||||
|
||||
int32_t mp4ff_read_sample(mp4ff_t *f, const int track, const int sample,
|
||||
unsigned char **audio_buffer, unsigned int *bytes);
|
||||
|
||||
int32_t mp4ff_read_sample_v2(mp4ff_t *f, const int track, const int sample,unsigned char *buffer);//returns 0 on error, number of bytes read on success, use mp4ff_read_sample_getsize() to check buffer size needed
|
||||
int32_t mp4ff_read_sample_getsize(mp4ff_t *f, const int track, const int sample);//returns 0 on error, buffer size needed for mp4ff_read_sample_v2() on success
|
||||
|
||||
|
||||
|
||||
int32_t mp4ff_get_decoder_config(const mp4ff_t *f, const int track,
|
||||
unsigned char** ppBuf, unsigned int* pBufSize);
|
||||
int32_t mp4ff_get_track_type(const mp4ff_t *f, const int track);
|
||||
int32_t mp4ff_total_tracks(const mp4ff_t *f);
|
||||
int32_t mp4ff_num_samples(const mp4ff_t *f, const int track);
|
||||
int32_t mp4ff_time_scale(const mp4ff_t *f, const int track);
|
||||
|
||||
uint32_t mp4ff_get_avg_bitrate(const mp4ff_t *f, const int32_t track);
|
||||
uint32_t mp4ff_get_max_bitrate(const mp4ff_t *f, const int32_t track);
|
||||
int64_t mp4ff_get_track_duration(const mp4ff_t *f, const int32_t track); //returns (-1) if unknown
|
||||
int64_t mp4ff_get_track_duration_use_offsets(const mp4ff_t *f, const int32_t track); //returns (-1) if unknown
|
||||
uint32_t mp4ff_get_sample_rate(const mp4ff_t *f, const int32_t track);
|
||||
uint32_t mp4ff_get_channel_count(const mp4ff_t * f,const int32_t track);
|
||||
uint32_t mp4ff_get_audio_type(const mp4ff_t * f,const int32_t track);
|
||||
|
||||
|
||||
/* metadata */
|
||||
int mp4ff_meta_get_num_items(const mp4ff_t *f);
|
||||
int mp4ff_meta_get_by_index(const mp4ff_t *f, unsigned int index,
|
||||
char **item, char **value);
|
||||
int mp4ff_meta_get_title(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_artist(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_writer(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_album(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_date(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_tool(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_comment(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_genre(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_track(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_disc(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_compilation(const mp4ff_t *f, char **value);
|
||||
int mp4ff_meta_get_tempo(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_coverart(const mp4ff_t *f, char **value);
|
||||
#ifdef USE_TAGGING
|
||||
|
||||
/* metadata tag structure */
|
||||
typedef struct
|
||||
{
|
||||
char *item;
|
||||
char *value;
|
||||
} mp4ff_tag_t;
|
||||
|
||||
/* metadata list structure */
|
||||
typedef struct
|
||||
{
|
||||
mp4ff_tag_t *tags;
|
||||
uint32_t count;
|
||||
} mp4ff_metadata_t;
|
||||
|
||||
int32_t mp4ff_meta_update(mp4ff_callback_t *f,const mp4ff_metadata_t * data);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,252 @@
|
|||
<?xml version="1.0" encoding="Windows-1252"?>
|
||||
<VisualStudioProject
|
||||
ProjectType="Visual C++"
|
||||
Version="7.10"
|
||||
Name="mp4ff"
|
||||
ProjectGUID="{F470BB4A-7675-4D6A-B310-41F33AC6F987}"
|
||||
SccProjectName=""
|
||||
SccLocalPath="">
|
||||
<Platforms>
|
||||
<Platform
|
||||
Name="Win32"/>
|
||||
</Platforms>
|
||||
<Configurations>
|
||||
<Configuration
|
||||
Name="Release|Win32"
|
||||
OutputDirectory=".\Release"
|
||||
IntermediateDirectory=".\Release"
|
||||
ConfigurationType="4"
|
||||
UseOfMFC="0"
|
||||
ATLMinimizesCRunTimeLibraryUsage="FALSE">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="1"
|
||||
InlineFunctionExpansion="1"
|
||||
PreprocessorDefinitions="USE_TAGGING"
|
||||
StringPooling="TRUE"
|
||||
RuntimeLibrary="2"
|
||||
EnableFunctionLevelLinking="TRUE"
|
||||
UsePrecompiledHeader="2"
|
||||
PrecompiledHeaderFile=".\Release/mp4ff.pch"
|
||||
AssemblerListingLocation=".\Release/"
|
||||
ObjectFile=".\Release/"
|
||||
ProgramDataBaseFileName=".\Release/"
|
||||
WarningLevel="3"
|
||||
SuppressStartupBanner="TRUE"
|
||||
Detect64BitPortabilityProblems="TRUE"/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
AdditionalOptions=""
|
||||
OutputFile=".\Release\mp4ff.lib"
|
||||
SuppressStartupBanner="TRUE"/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"/>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
PreprocessorDefinitions="NDEBUG"
|
||||
Culture="1043"/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"/>
|
||||
<Tool
|
||||
Name="VCManagedWrapperGeneratorTool"/>
|
||||
<Tool
|
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
Name="Debug|Win32"
|
||||
OutputDirectory=".\Debug"
|
||||
IntermediateDirectory=".\Debug"
|
||||
ConfigurationType="4"
|
||||
UseOfMFC="0"
|
||||
ATLMinimizesCRunTimeLibraryUsage="FALSE">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions="USE_TAGGING"
|
||||
BasicRuntimeChecks="3"
|
||||
RuntimeLibrary="3"
|
||||
UsePrecompiledHeader="2"
|
||||
PrecompiledHeaderFile=".\Debug/mp4ff.pch"
|
||||
AssemblerListingLocation=".\Debug/"
|
||||
ObjectFile=".\Debug/"
|
||||
ProgramDataBaseFileName=".\Debug/"
|
||||
WarningLevel="3"
|
||||
SuppressStartupBanner="TRUE"
|
||||
DebugInformationFormat="4"/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
AdditionalOptions=""
|
||||
OutputFile=".\Debug\mp4ff.lib"
|
||||
SuppressStartupBanner="TRUE"/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"/>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
PreprocessorDefinitions="_DEBUG"
|
||||
Culture="1043"/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"/>
|
||||
<Tool
|
||||
Name="VCManagedWrapperGeneratorTool"/>
|
||||
<Tool
|
||||
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
|
||||
</Configuration>
|
||||
</Configurations>
|
||||
<References>
|
||||
</References>
|
||||
<Files>
|
||||
<Filter
|
||||
Name="Source Files"
|
||||
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
|
||||
<File
|
||||
RelativePath=".\drms.c">
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mp4atom.c">
|
||||
<FileConfiguration
|
||||
Name="Release|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="1"
|
||||
PreprocessorDefinitions=""/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions=""
|
||||
BasicRuntimeChecks="3"/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mp4ff.c">
|
||||
<FileConfiguration
|
||||
Name="Release|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="1"
|
||||
PreprocessorDefinitions=""/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions=""
|
||||
BasicRuntimeChecks="3"/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mp4meta.c">
|
||||
<FileConfiguration
|
||||
Name="Release|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="1"
|
||||
PreprocessorDefinitions=""/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions=""
|
||||
BasicRuntimeChecks="3"/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mp4sample.c">
|
||||
<FileConfiguration
|
||||
Name="Release|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="1"
|
||||
PreprocessorDefinitions=""/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions=""
|
||||
BasicRuntimeChecks="3"/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\mp4tagupdate.c">
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mp4util.c">
|
||||
<FileConfiguration
|
||||
Name="Release|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="1"
|
||||
PreprocessorDefinitions=""/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalOptions=""
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions=""
|
||||
BasicRuntimeChecks="3"/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Header Files"
|
||||
Filter="h;hpp;hxx;hm;inl">
|
||||
<File
|
||||
RelativePath=".\drms.h">
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\drmstables.h">
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\mp4ff.h">
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\mp4ff_int_types.h">
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mp4ffint.h">
|
||||
</File>
|
||||
</Filter>
|
||||
</Files>
|
||||
<Globals>
|
||||
</Globals>
|
||||
</VisualStudioProject>
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#ifndef _MP4FF_INT_TYPES_H_
|
||||
#define _MP4FF_INT_TYPES_H_
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
typedef char int8_t;
|
||||
typedef unsigned char uint8_t;
|
||||
typedef short int16_t;
|
||||
typedef unsigned short uint16_t;
|
||||
typedef long int32_t;
|
||||
typedef unsigned long uint32_t;
|
||||
|
||||
typedef __int64 int64_t;
|
||||
typedef unsigned __int64 uint64_t;
|
||||
|
||||
#else
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,329 @@
|
|||
/*
|
||||
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
||||
** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
|
||||
**
|
||||
** This program is free software; you can redistribute it and/or modify
|
||||
** it under the terms of the GNU General Public License as published by
|
||||
** the Free Software Foundation; either version 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** This program is distributed in the hope that it will be useful,
|
||||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
** GNU General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program; if not, write to the Free Software
|
||||
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
**
|
||||
** Any non-GPL usage of this software or parts of this software is strictly
|
||||
** forbidden.
|
||||
**
|
||||
** Commercial non-GPL licensing of this software is possible.
|
||||
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
||||
**
|
||||
** $Id: mp4ffint.h,v 1.15 2004/01/14 20:50:22 menno Exp $
|
||||
**/
|
||||
|
||||
#ifndef MP4FF_INTERNAL_H
|
||||
#define MP4FF_INTERNAL_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#include "mp4ff_int_types.h"
|
||||
|
||||
|
||||
#ifdef _WIN32
|
||||
#define ITUNES_DRM
|
||||
#endif
|
||||
|
||||
|
||||
#define MAX_TRACKS 1024
|
||||
#define TRACK_UNKNOWN 0
|
||||
#define TRACK_AUDIO 1
|
||||
#define TRACK_VIDEO 2
|
||||
#define TRACK_SYSTEM 3
|
||||
|
||||
|
||||
#define SUBATOMIC 128
|
||||
|
||||
/* atoms without subatoms */
|
||||
#define ATOM_FTYP 129
|
||||
#define ATOM_MDAT 130
|
||||
#define ATOM_MVHD 131
|
||||
#define ATOM_TKHD 132
|
||||
#define ATOM_TREF 133
|
||||
#define ATOM_MDHD 134
|
||||
#define ATOM_VMHD 135
|
||||
#define ATOM_SMHD 136
|
||||
#define ATOM_HMHD 137
|
||||
#define ATOM_STSD 138
|
||||
#define ATOM_STTS 139
|
||||
#define ATOM_STSZ 140
|
||||
#define ATOM_STZ2 141
|
||||
#define ATOM_STCO 142
|
||||
#define ATOM_STSC 143
|
||||
#define ATOM_MP4A 144
|
||||
#define ATOM_MP4V 145
|
||||
#define ATOM_MP4S 146
|
||||
#define ATOM_ESDS 147
|
||||
#define ATOM_META 148 /* iTunes Metadata box */
|
||||
#define ATOM_NAME 149 /* iTunes Metadata name box */
|
||||
#define ATOM_DATA 150 /* iTunes Metadata data box */
|
||||
#define ATOM_CTTS 151
|
||||
#define ATOM_FRMA 152
|
||||
#define ATOM_IVIV 153
|
||||
#define ATOM_PRIV 154
|
||||
|
||||
#define ATOM_UNKNOWN 255
|
||||
#define ATOM_FREE ATOM_UNKNOWN
|
||||
#define ATOM_SKIP ATOM_UNKNOWN
|
||||
|
||||
/* atoms with subatoms */
|
||||
#define ATOM_MOOV 1
|
||||
#define ATOM_TRAK 2
|
||||
#define ATOM_EDTS 3
|
||||
#define ATOM_MDIA 4
|
||||
#define ATOM_MINF 5
|
||||
#define ATOM_STBL 6
|
||||
#define ATOM_UDTA 7
|
||||
#define ATOM_ILST 8 /* iTunes Metadata list */
|
||||
#define ATOM_TITLE 9
|
||||
#define ATOM_ARTIST 10
|
||||
#define ATOM_WRITER 11
|
||||
#define ATOM_ALBUM 12
|
||||
#define ATOM_DATE 13
|
||||
#define ATOM_TOOL 14
|
||||
#define ATOM_COMMENT 15
|
||||
#define ATOM_GENRE1 16
|
||||
#define ATOM_TRACK 17
|
||||
#define ATOM_DISC 18
|
||||
#define ATOM_COMPILATION 19
|
||||
#define ATOM_GENRE2 20
|
||||
#define ATOM_TEMPO 21
|
||||
#define ATOM_COVER 22
|
||||
#define ATOM_DRMS 23
|
||||
#define ATOM_SINF 24
|
||||
#define ATOM_SCHI 25
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "../../config.h"
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32
|
||||
#define stricmp strcasecmp
|
||||
#endif
|
||||
|
||||
/* file callback structure */
|
||||
typedef struct
|
||||
{
|
||||
uint32_t (*read)(void *user_data, void *buffer, uint32_t length);
|
||||
uint32_t (*write)(void *udata, void *buffer, uint32_t length);
|
||||
uint32_t (*seek)(void *user_data, uint64_t position);
|
||||
uint32_t (*truncate)(void *user_data);
|
||||
void *user_data;
|
||||
} mp4ff_callback_t;
|
||||
|
||||
|
||||
/* metadata tag structure */
|
||||
typedef struct
|
||||
{
|
||||
char *item;
|
||||
char *value;
|
||||
} mp4ff_tag_t;
|
||||
|
||||
/* metadata list structure */
|
||||
typedef struct
|
||||
{
|
||||
mp4ff_tag_t *tags;
|
||||
uint32_t count;
|
||||
} mp4ff_metadata_t;
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int32_t type;
|
||||
int32_t channelCount;
|
||||
int32_t sampleSize;
|
||||
uint16_t sampleRate;
|
||||
int32_t audioType;
|
||||
|
||||
/* stsd */
|
||||
int32_t stsd_entry_count;
|
||||
|
||||
/* stsz */
|
||||
int32_t stsz_sample_size;
|
||||
int32_t stsz_sample_count;
|
||||
int32_t *stsz_table;
|
||||
|
||||
/* stts */
|
||||
int32_t stts_entry_count;
|
||||
int32_t *stts_sample_count;
|
||||
int32_t *stts_sample_delta;
|
||||
|
||||
/* stsc */
|
||||
int32_t stsc_entry_count;
|
||||
int32_t *stsc_first_chunk;
|
||||
int32_t *stsc_samples_per_chunk;
|
||||
int32_t *stsc_sample_desc_index;
|
||||
|
||||
/* stsc */
|
||||
int32_t stco_entry_count;
|
||||
int32_t *stco_chunk_offset;
|
||||
|
||||
/* ctts */
|
||||
int32_t ctts_entry_count;
|
||||
int32_t *ctts_sample_count;
|
||||
int32_t *ctts_sample_offset;
|
||||
|
||||
/* esde */
|
||||
uint8_t *decoderConfig;
|
||||
int32_t decoderConfigLen;
|
||||
|
||||
uint32_t maxBitrate;
|
||||
uint32_t avgBitrate;
|
||||
|
||||
uint32_t timeScale;
|
||||
uint64_t duration;
|
||||
|
||||
#ifdef ITUNES_DRM
|
||||
/* drms */
|
||||
void *p_drms;
|
||||
#endif
|
||||
|
||||
} mp4ff_track_t;
|
||||
|
||||
/* mp4 main file structure */
|
||||
typedef struct
|
||||
{
|
||||
/* stream to read from */
|
||||
mp4ff_callback_t *stream;
|
||||
int64_t current_position;
|
||||
|
||||
int32_t moov_read;
|
||||
uint64_t moov_offset;
|
||||
uint64_t moov_size;
|
||||
uint8_t last_atom;
|
||||
uint64_t file_size;
|
||||
|
||||
/* mvhd */
|
||||
int32_t time_scale;
|
||||
int32_t duration;
|
||||
|
||||
/* incremental track index while reading the file */
|
||||
int32_t total_tracks;
|
||||
|
||||
/* track data */
|
||||
mp4ff_track_t *track[MAX_TRACKS];
|
||||
|
||||
/* metadata */
|
||||
mp4ff_metadata_t tags;
|
||||
} mp4ff_t;
|
||||
|
||||
|
||||
|
||||
|
||||
/* mp4util.c */
|
||||
int32_t mp4ff_read_data(mp4ff_t *f, int8_t *data, uint32_t size);
|
||||
int32_t mp4ff_write_data(mp4ff_t *f, int8_t *data, uint32_t size);
|
||||
uint64_t mp4ff_read_int64(mp4ff_t *f);
|
||||
uint32_t mp4ff_read_int32(mp4ff_t *f);
|
||||
uint32_t mp4ff_read_int24(mp4ff_t *f);
|
||||
uint16_t mp4ff_read_int16(mp4ff_t *f);
|
||||
uint8_t mp4ff_read_char(mp4ff_t *f);
|
||||
int32_t mp4ff_write_int32(mp4ff_t *f,const uint32_t data);
|
||||
uint32_t mp4ff_read_mp4_descr_length(mp4ff_t *f);
|
||||
int64_t mp4ff_position(const mp4ff_t *f);
|
||||
int32_t mp4ff_set_position(mp4ff_t *f, const int64_t position);
|
||||
int32_t mp4ff_truncate(mp4ff_t * f);
|
||||
char * mp4ff_read_string(mp4ff_t * f,uint32_t length);
|
||||
|
||||
/* mp4atom.c */
|
||||
static int32_t mp4ff_atom_get_size(const int8_t *data);
|
||||
static int32_t mp4ff_atom_compare(const int8_t a1, const int8_t b1, const int8_t c1, const int8_t d1,
|
||||
const int8_t a2, const int8_t b2, const int8_t c2, const int8_t d2);
|
||||
static uint8_t mp4ff_atom_name_to_type(const int8_t a, const int8_t b, const int8_t c, const int8_t d);
|
||||
uint64_t mp4ff_atom_read_header(mp4ff_t *f, uint8_t *atom_type, uint8_t *header_size);
|
||||
static int32_t mp4ff_read_stsz(mp4ff_t *f);
|
||||
static int32_t mp4ff_read_esds(mp4ff_t *f);
|
||||
static int32_t mp4ff_read_mp4a(mp4ff_t *f);
|
||||
static int32_t mp4ff_read_stsd(mp4ff_t *f);
|
||||
static int32_t mp4ff_read_stsc(mp4ff_t *f);
|
||||
static int32_t mp4ff_read_stco(mp4ff_t *f);
|
||||
static int32_t mp4ff_read_stts(mp4ff_t *f);
|
||||
#ifdef USE_TAGGING
|
||||
static int32_t mp4ff_read_meta(mp4ff_t *f, const uint64_t size);
|
||||
#endif
|
||||
int32_t mp4ff_atom_read(mp4ff_t *f, const int32_t size, const uint8_t atom_type);
|
||||
|
||||
/* mp4sample.c */
|
||||
static int32_t mp4ff_chunk_of_sample(const mp4ff_t *f, const int32_t track, const int32_t sample,
|
||||
int32_t *chunk_sample, int32_t *chunk);
|
||||
static int32_t mp4ff_chunk_to_offset(const mp4ff_t *f, const int32_t track, const int32_t chunk);
|
||||
static int32_t mp4ff_sample_range_size(const mp4ff_t *f, const int32_t track,
|
||||
const int32_t chunk_sample, const int32_t sample);
|
||||
static int32_t mp4ff_sample_to_offset(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int32_t mp4ff_audio_frame_size(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int32_t mp4ff_set_sample_position(mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
|
||||
#ifdef USE_TAGGING
|
||||
/* mp4meta.c */
|
||||
static int32_t mp4ff_tag_add_field(mp4ff_metadata_t *tags, const char *item, const char *value);
|
||||
static int32_t mp4ff_tag_set_field(mp4ff_metadata_t *tags, const char *item, const char *value);
|
||||
static int32_t mp4ff_set_metadata_name(mp4ff_t *f, const uint8_t atom_type, char **name);
|
||||
static int32_t mp4ff_parse_tag(mp4ff_t *f, const uint8_t parent_atom_type, const int32_t size);
|
||||
static int32_t mp4ff_meta_find_by_name(const mp4ff_t *f, const char *item, char **value);
|
||||
int32_t mp4ff_parse_metadata(mp4ff_t *f, const int32_t size);
|
||||
int32_t mp4ff_tag_delete(mp4ff_metadata_t *tags);
|
||||
int32_t mp4ff_meta_get_num_items(const mp4ff_t *f);
|
||||
int32_t mp4ff_meta_get_by_index(const mp4ff_t *f, uint32_t index,
|
||||
char **item, char **value);
|
||||
int32_t mp4ff_meta_get_title(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_artist(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_writer(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_album(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_date(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_tool(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_comment(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_genre(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_track(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_disc(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_compilation(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_tempo(const mp4ff_t *f, char **value);
|
||||
int32_t mp4ff_meta_get_coverart(const mp4ff_t *f, char **value);
|
||||
#endif
|
||||
|
||||
/* mp4ff.c */
|
||||
mp4ff_t *mp4ff_open_read(mp4ff_callback_t *f);
|
||||
#ifdef USE_TAGGING
|
||||
mp4ff_t *mp4ff_open_edit(mp4ff_callback_t *f);
|
||||
#endif
|
||||
void mp4ff_close(mp4ff_t *ff);
|
||||
/*void mp4ff_track_add(mp4ff_t *f);*/
|
||||
int32_t parse_sub_atoms(mp4ff_t *f, const uint64_t total_size);
|
||||
int32_t parse_atoms(mp4ff_t *f);
|
||||
|
||||
int32_t mp4ff_get_sample_duration(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int64_t mp4ff_get_sample_position(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int32_t mp4ff_get_sample_offset(const mp4ff_t *f, const int32_t track, const int32_t sample);
|
||||
int32_t mp4ff_find_sample(const mp4ff_t *f, const int32_t track, const int64_t offset,int32_t * toskip);
|
||||
|
||||
int32_t mp4ff_read_sample(mp4ff_t *f, const int32_t track, const int32_t sample,
|
||||
uint8_t **audio_buffer, uint32_t *bytes);
|
||||
int32_t mp4ff_get_decoder_config(const mp4ff_t *f, const int32_t track,
|
||||
uint8_t** ppBuf, uint32_t* pBufSize);
|
||||
int32_t mp4ff_total_tracks(const mp4ff_t *f);
|
||||
int32_t mp4ff_time_scale(const mp4ff_t *f, const int32_t track);
|
||||
int32_t mp4ff_num_samples(const mp4ff_t *f, const int32_t track);
|
||||
|
||||
uint32_t mp4ff_meta_genre_to_index(const char * genrestr);//returns 1-based index, 0 if not found
|
||||
const char * mp4ff_meta_index_to_genre(uint32_t idx);//returns pointer to static string
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,414 @@
|
|||
/*
|
||||
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
||||
** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
|
||||
**
|
||||
** This program is free software; you can redistribute it and/or modify
|
||||
** it under the terms of the GNU General Public License as published by
|
||||
** the Free Software Foundation; either version 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** This program is distributed in the hope that it will be useful,
|
||||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
** GNU General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program; if not, write to the Free Software
|
||||
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
**
|
||||
** Any non-GPL usage of this software or parts of this software is strictly
|
||||
** forbidden.
|
||||
**
|
||||
** Commercial non-GPL licensing of this software is possible.
|
||||
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
||||
**
|
||||
** $Id: mp4meta.c,v 1.13 2004/01/11 15:52:18 menno Exp $
|
||||
**/
|
||||
|
||||
#ifdef USE_TAGGING
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "mp4ffint.h"
|
||||
|
||||
static int32_t mp4ff_tag_add_field(mp4ff_metadata_t *tags, const char *item, const char *value)
|
||||
{
|
||||
void *backup = (void *)tags->tags;
|
||||
|
||||
if (!item || (item && !*item) || !value) return 0;
|
||||
|
||||
tags->tags = (mp4ff_tag_t*)realloc(tags->tags, (tags->count+1) * sizeof(mp4ff_tag_t));
|
||||
if (!tags->tags)
|
||||
{
|
||||
if (backup) free(backup);
|
||||
return 0;
|
||||
} else {
|
||||
tags->tags[tags->count].item = strdup(item);
|
||||
tags->tags[tags->count].value = strdup(value);
|
||||
|
||||
if (!tags->tags[tags->count].item || !tags->tags[tags->count].value)
|
||||
{
|
||||
if (!tags->tags[tags->count].item) free (tags->tags[tags->count].item);
|
||||
if (!tags->tags[tags->count].value) free (tags->tags[tags->count].value);
|
||||
tags->tags[tags->count].item = NULL;
|
||||
tags->tags[tags->count].value = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
tags->count++;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
static int32_t mp4ff_tag_set_field(mp4ff_metadata_t *tags, const char *item, const char *value)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
if (!item || (item && !*item) || !value) return 0;
|
||||
|
||||
for (i = 0; i < tags->count; i++)
|
||||
{
|
||||
if (!stricmp(tags->tags[i].item, item))
|
||||
{
|
||||
free(tags->tags[i].value);
|
||||
tags->tags[i].value = strdup(value);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
return mp4ff_tag_add_field(tags, item, value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_tag_delete(mp4ff_metadata_t *tags)
|
||||
{
|
||||
uint32_t i;
|
||||
|
||||
for (i = 0; i < tags->count; i++)
|
||||
{
|
||||
if (tags->tags[i].item) free(tags->tags[i].item);
|
||||
if (tags->tags[i].value) free(tags->tags[i].value);
|
||||
}
|
||||
|
||||
if (tags->tags) free(tags->tags);
|
||||
|
||||
tags->tags = NULL;
|
||||
tags->count = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const char* ID3v1GenreList[] = {
|
||||
"Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk",
|
||||
"Grunge", "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies",
|
||||
"Other", "Pop", "R&B", "Rap", "Reggae", "Rock",
|
||||
"Techno", "Industrial", "Alternative", "Ska", "Death Metal", "Pranks",
|
||||
"Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz+Funk",
|
||||
"Fusion", "Trance", "Classical", "Instrumental", "Acid", "House",
|
||||
"Game", "Sound Clip", "Gospel", "Noise", "AlternRock", "Bass",
|
||||
"Soul", "Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock",
|
||||
"Ethnic", "Gothic", "Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk",
|
||||
"Eurodance", "Dream", "Southern Rock", "Comedy", "Cult", "Gangsta",
|
||||
"Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American", "Cabaret",
|
||||
"New Wave", "Psychadelic", "Rave", "Showtunes", "Trailer", "Lo-Fi",
|
||||
"Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical",
|
||||
"Rock & Roll", "Hard Rock", "Folk", "Folk/Rock", "National Folk", "Swing",
|
||||
"Fast-Fusion", "Bebob", "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde",
|
||||
"Gothic Rock", "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock", "Big Band",
|
||||
"Chorus", "Easy Listening", "Acoustic", "Humour", "Speech", "Chanson",
|
||||
"Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass", "Primus",
|
||||
"Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
|
||||
"Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle", "Duet",
|
||||
"Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
|
||||
"Goa", "Drum & Bass", "Club House", "Hardcore", "Terror",
|
||||
"Indie", "BritPop", "NegerPunk", "Polsk Punk", "Beat",
|
||||
"Christian Gangsta", "Heavy Metal", "Black Metal", "Crossover", "Contemporary C",
|
||||
"Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "JPop",
|
||||
"SynthPop",
|
||||
};
|
||||
|
||||
uint32_t mp4ff_meta_genre_to_index(const char * genrestr)
|
||||
{
|
||||
unsigned n;
|
||||
for(n=0;n<sizeof(ID3v1GenreList)/sizeof(ID3v1GenreList[0]);n++)
|
||||
{
|
||||
if (!stricmp(genrestr,ID3v1GenreList[n])) return n+1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char * mp4ff_meta_index_to_genre(uint32_t idx)
|
||||
{
|
||||
if (idx>0 && idx<=sizeof(ID3v1GenreList)/sizeof(ID3v1GenreList[0]))
|
||||
{
|
||||
return ID3v1GenreList[idx-1];
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int32_t TrackToString(char** str, const uint16_t track, const uint16_t totalTracks)
|
||||
{
|
||||
char temp[32];
|
||||
sprintf(temp, "%.5u of %.5u", track, totalTracks);
|
||||
*str = strdup(temp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_set_metadata_name(mp4ff_t *f, const uint8_t atom_type, char **name)
|
||||
{
|
||||
static char *tag_names[] = {
|
||||
"unknown", "title", "artist", "writer", "album",
|
||||
"date", "tool", "comment", "genre", "track",
|
||||
"disc", "compilation", "genre", "tempo", "cover"
|
||||
};
|
||||
uint8_t tag_idx = 0;
|
||||
|
||||
switch (atom_type)
|
||||
{
|
||||
case ATOM_TITLE: tag_idx = 1; break;
|
||||
case ATOM_ARTIST: tag_idx = 2; break;
|
||||
case ATOM_WRITER: tag_idx = 3; break;
|
||||
case ATOM_ALBUM: tag_idx = 4; break;
|
||||
case ATOM_DATE: tag_idx = 5; break;
|
||||
case ATOM_TOOL: tag_idx = 6; break;
|
||||
case ATOM_COMMENT: tag_idx = 7; break;
|
||||
case ATOM_GENRE1: tag_idx = 8; break;
|
||||
case ATOM_TRACK: tag_idx = 9; break;
|
||||
case ATOM_DISC: tag_idx = 10; break;
|
||||
case ATOM_COMPILATION: tag_idx = 11; break;
|
||||
case ATOM_GENRE2: tag_idx = 12; break;
|
||||
case ATOM_TEMPO: tag_idx = 13; break;
|
||||
case ATOM_COVER: tag_idx = 14; break;
|
||||
default: tag_idx = 0; break;
|
||||
}
|
||||
|
||||
*name = strdup(tag_names[tag_idx]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_parse_tag(mp4ff_t *f, const uint8_t parent_atom_type, const int32_t size)
|
||||
{
|
||||
uint8_t atom_type;
|
||||
uint8_t header_size = 0;
|
||||
uint64_t subsize, sumsize = 0;
|
||||
char * name = NULL;
|
||||
char * data = NULL;
|
||||
uint32_t done = 0;
|
||||
|
||||
|
||||
while (sumsize < size)
|
||||
{
|
||||
uint64_t destpos;
|
||||
subsize = mp4ff_atom_read_header(f, &atom_type, &header_size);
|
||||
destpos = mp4ff_position(f)+subsize-header_size;
|
||||
if (!done)
|
||||
{
|
||||
if (atom_type == ATOM_DATA)
|
||||
{
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
mp4ff_read_int32(f); /* reserved */
|
||||
|
||||
/* some need special attention */
|
||||
if (parent_atom_type == ATOM_GENRE2 || parent_atom_type == ATOM_TEMPO)
|
||||
{
|
||||
if (subsize - header_size >= 8 + 2)
|
||||
{
|
||||
uint16_t val = mp4ff_read_int16(f);
|
||||
|
||||
if (parent_atom_type == ATOM_TEMPO)
|
||||
{
|
||||
char temp[16];
|
||||
sprintf(temp, "%.5u BPM", val);
|
||||
mp4ff_tag_add_field(&(f->tags), "tempo", temp);
|
||||
}
|
||||
else
|
||||
{
|
||||
const char * temp = mp4ff_meta_index_to_genre(val);
|
||||
if (temp)
|
||||
{
|
||||
mp4ff_tag_add_field(&(f->tags), "genre", temp);
|
||||
}
|
||||
}
|
||||
done = 1;
|
||||
}
|
||||
} else if (parent_atom_type == ATOM_TRACK || parent_atom_type == ATOM_DISC) {
|
||||
if (!done && subsize - header_size >= 8 + 8)
|
||||
{
|
||||
uint16_t index,total;
|
||||
char temp[32];
|
||||
mp4ff_read_int16(f);
|
||||
index = mp4ff_read_int16(f);
|
||||
total = mp4ff_read_int16(f);
|
||||
mp4ff_read_int16(f);
|
||||
|
||||
sprintf(temp,"%d",index);
|
||||
mp4ff_tag_add_field(&(f->tags), parent_atom_type == ATOM_TRACK ? "track" : "disc", temp);
|
||||
if (total>0)
|
||||
{
|
||||
sprintf(temp,"%d",total);
|
||||
mp4ff_tag_add_field(&(f->tags), parent_atom_type == ATOM_TRACK ? "totaltracks" : "totaldiscs", temp);
|
||||
}
|
||||
done = 1;
|
||||
}
|
||||
} else
|
||||
{
|
||||
if (data) {free(data);data = NULL;}
|
||||
data = mp4ff_read_string(f,(uint32_t)(subsize-(header_size+8)));
|
||||
}
|
||||
} else if (atom_type == ATOM_NAME) {
|
||||
if (!done)
|
||||
{
|
||||
mp4ff_read_char(f); /* version */
|
||||
mp4ff_read_int24(f); /* flags */
|
||||
if (name) free(name);
|
||||
name = mp4ff_read_string(f,(uint32_t)(subsize-(header_size+4)));
|
||||
}
|
||||
}
|
||||
mp4ff_set_position(f, destpos);
|
||||
sumsize += subsize;
|
||||
}
|
||||
}
|
||||
|
||||
if (data)
|
||||
{
|
||||
if (!done)
|
||||
{
|
||||
if (name == NULL) mp4ff_set_metadata_name(f, parent_atom_type, &name);
|
||||
if (name) mp4ff_tag_add_field(&(f->tags), name, data);
|
||||
}
|
||||
|
||||
free(data);
|
||||
}
|
||||
if (name) free(name);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int32_t mp4ff_parse_metadata(mp4ff_t *f, const int32_t size)
|
||||
{
|
||||
uint64_t subsize, sumsize = 0;
|
||||
uint8_t atom_type;
|
||||
uint8_t header_size = 0;
|
||||
|
||||
while (sumsize < size)
|
||||
{
|
||||
subsize = mp4ff_atom_read_header(f, &atom_type, &header_size);
|
||||
mp4ff_parse_tag(f, atom_type, (uint32_t)(subsize-header_size));
|
||||
sumsize += subsize;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* find a metadata item by name */
|
||||
/* returns 0 if item found, 1 if no such item */
|
||||
static int32_t mp4ff_meta_find_by_name(const mp4ff_t *f, const char *item, char **value)
|
||||
{
|
||||
uint32_t i;
|
||||
|
||||
for (i = 0; i < f->tags.count; i++)
|
||||
{
|
||||
if (!stricmp(f->tags.tags[i].item, item))
|
||||
{
|
||||
*value = strdup(f->tags.tags[i].value);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
*value = NULL;
|
||||
|
||||
/* not found */
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_num_items(const mp4ff_t *f)
|
||||
{
|
||||
return f->tags.count;
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_by_index(const mp4ff_t *f, uint32_t index,
|
||||
char **item, char **value)
|
||||
{
|
||||
if (index >= f->tags.count)
|
||||
{
|
||||
*item = NULL;
|
||||
*value = NULL;
|
||||
return 0;
|
||||
} else {
|
||||
*item = strdup(f->tags.tags[index].item);
|
||||
*value = strdup(f->tags.tags[index].value);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_title(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "title", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_artist(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "artist", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_writer(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "writer", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_album(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "album", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_date(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "date", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_tool(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "tool", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_comment(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "comment", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_genre(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "genre", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_track(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "track", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_disc(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "disc", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_compilation(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "compilation", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_tempo(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "tempo", value);
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_get_coverart(const mp4ff_t *f, char **value)
|
||||
{
|
||||
return mp4ff_meta_find_by_name(f, "cover", value);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,152 @@
|
|||
/*
|
||||
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
||||
** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
|
||||
**
|
||||
** This program is free software; you can redistribute it and/or modify
|
||||
** it under the terms of the GNU General Public License as published by
|
||||
** the Free Software Foundation; either version 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** This program is distributed in the hope that it will be useful,
|
||||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
** GNU General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program; if not, write to the Free Software
|
||||
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
**
|
||||
** Any non-GPL usage of this software or parts of this software is strictly
|
||||
** forbidden.
|
||||
**
|
||||
** Commercial non-GPL licensing of this software is possible.
|
||||
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
||||
**
|
||||
** $Id: mp4sample.c,v 1.15 2004/01/11 15:52:19 menno Exp $
|
||||
**/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "mp4ffint.h"
|
||||
|
||||
|
||||
static int32_t mp4ff_chunk_of_sample(const mp4ff_t *f, const int32_t track, const int32_t sample,
|
||||
int32_t *chunk_sample, int32_t *chunk)
|
||||
{
|
||||
int32_t total_entries = 0;
|
||||
int32_t chunk2entry;
|
||||
int32_t chunk1, chunk2, chunk1samples, range_samples, total = 0;
|
||||
|
||||
if (f->track[track] == NULL)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
total_entries = f->track[track]->stsc_entry_count;
|
||||
|
||||
chunk1 = 1;
|
||||
chunk1samples = 0;
|
||||
chunk2entry = 0;
|
||||
|
||||
do
|
||||
{
|
||||
chunk2 = f->track[track]->stsc_first_chunk[chunk2entry];
|
||||
*chunk = chunk2 - chunk1;
|
||||
range_samples = *chunk * chunk1samples;
|
||||
|
||||
if (sample < total + range_samples) break;
|
||||
|
||||
chunk1samples = f->track[track]->stsc_samples_per_chunk[chunk2entry];
|
||||
chunk1 = chunk2;
|
||||
|
||||
if(chunk2entry < total_entries)
|
||||
{
|
||||
chunk2entry++;
|
||||
total += range_samples;
|
||||
}
|
||||
} while (chunk2entry < total_entries);
|
||||
|
||||
if (chunk1samples)
|
||||
*chunk = (sample - total) / chunk1samples + chunk1;
|
||||
else
|
||||
*chunk = 1;
|
||||
|
||||
*chunk_sample = total + (*chunk - chunk1) * chunk1samples;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_chunk_to_offset(const mp4ff_t *f, const int32_t track, const int32_t chunk)
|
||||
{
|
||||
const mp4ff_track_t * p_track = f->track[track];
|
||||
|
||||
if (p_track->stco_entry_count && (chunk > p_track->stco_entry_count))
|
||||
{
|
||||
return p_track->stco_chunk_offset[p_track->stco_entry_count - 1];
|
||||
} else if (p_track->stco_entry_count) {
|
||||
return p_track->stco_chunk_offset[chunk - 1];
|
||||
} else {
|
||||
return 8;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_sample_range_size(const mp4ff_t *f, const int32_t track,
|
||||
const int32_t chunk_sample, const int32_t sample)
|
||||
{
|
||||
int32_t i, total;
|
||||
const mp4ff_track_t * p_track = f->track[track];
|
||||
|
||||
if (p_track->stsz_sample_size)
|
||||
{
|
||||
return (sample - chunk_sample) * p_track->stsz_sample_size;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (sample>=p_track->stsz_sample_count) return 0;//error
|
||||
|
||||
for(i = chunk_sample, total = 0; i < sample; i++)
|
||||
{
|
||||
total += p_track->stsz_table[i];
|
||||
}
|
||||
}
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
static int32_t mp4ff_sample_to_offset(const mp4ff_t *f, const int32_t track, const int32_t sample)
|
||||
{
|
||||
int32_t chunk, chunk_sample, chunk_offset1, chunk_offset2;
|
||||
|
||||
mp4ff_chunk_of_sample(f, track, sample, &chunk_sample, &chunk);
|
||||
|
||||
chunk_offset1 = mp4ff_chunk_to_offset(f, track, chunk);
|
||||
chunk_offset2 = chunk_offset1 + mp4ff_sample_range_size(f, track, chunk_sample, sample);
|
||||
|
||||
return chunk_offset2;
|
||||
}
|
||||
|
||||
int32_t mp4ff_audio_frame_size(const mp4ff_t *f, const int32_t track, const int32_t sample)
|
||||
{
|
||||
int32_t bytes;
|
||||
const mp4ff_track_t * p_track = f->track[track];
|
||||
|
||||
if (p_track->stsz_sample_size)
|
||||
{
|
||||
bytes = p_track->stsz_sample_size;
|
||||
} else {
|
||||
bytes = p_track->stsz_table[sample];
|
||||
}
|
||||
|
||||
return bytes;
|
||||
}
|
||||
|
||||
int32_t mp4ff_set_sample_position(mp4ff_t *f, const int32_t track, const int32_t sample)
|
||||
{
|
||||
int32_t offset;
|
||||
|
||||
offset = mp4ff_sample_to_offset(f, track, sample);
|
||||
mp4ff_set_position(f, offset);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,645 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "mp4ffint.h"
|
||||
|
||||
#ifdef USE_TAGGING
|
||||
|
||||
static uint32_t fix_byte_order_32(uint32_t src)
|
||||
{
|
||||
uint32_t result;
|
||||
uint32_t a, b, c, d;
|
||||
int8_t data[4];
|
||||
|
||||
memcpy(data,&src,sizeof(src));
|
||||
a = (uint8_t)data[0];
|
||||
b = (uint8_t)data[1];
|
||||
c = (uint8_t)data[2];
|
||||
d = (uint8_t)data[3];
|
||||
|
||||
result = (a<<24) | (b<<16) | (c<<8) | d;
|
||||
return (uint32_t)result;
|
||||
}
|
||||
|
||||
static uint16_t fix_byte_order_16(uint16_t src)
|
||||
{
|
||||
uint16_t result;
|
||||
uint16_t a, b;
|
||||
int8_t data[2];
|
||||
|
||||
memcpy(data,&src,sizeof(src));
|
||||
a = (uint8_t)data[0];
|
||||
b = (uint8_t)data[1];
|
||||
|
||||
result = (a<<8) | b;
|
||||
return (uint16_t)result;
|
||||
}
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
void * data;
|
||||
unsigned written;
|
||||
unsigned allocated;
|
||||
unsigned error;
|
||||
} membuffer;
|
||||
|
||||
unsigned membuffer_write(membuffer * buf,const void * ptr,unsigned bytes)
|
||||
{
|
||||
unsigned dest_size = buf->written + bytes;
|
||||
|
||||
if (buf->error) return 0;
|
||||
if (dest_size > buf->allocated)
|
||||
{
|
||||
do
|
||||
{
|
||||
buf->allocated <<= 1;
|
||||
} while(dest_size > buf->allocated);
|
||||
|
||||
{
|
||||
void * newptr = realloc(buf->data,buf->allocated);
|
||||
if (newptr==0)
|
||||
{
|
||||
free(buf->data);
|
||||
buf->data = 0;
|
||||
buf->error = 1;
|
||||
return 0;
|
||||
}
|
||||
buf->data = newptr;
|
||||
}
|
||||
}
|
||||
|
||||
if (ptr) memcpy((char*)buf->data + buf->written,ptr,bytes);
|
||||
buf->written += bytes;
|
||||
return bytes;
|
||||
}
|
||||
|
||||
#define membuffer_write_data membuffer_write
|
||||
|
||||
unsigned membuffer_write_int32(membuffer * buf,uint32_t data)
|
||||
{
|
||||
uint8_t temp[4] = {(uint8_t)(data>>24),(uint8_t)(data>>16),(uint8_t)(data>>8),(uint8_t)data};
|
||||
return membuffer_write_data(buf,temp,4);
|
||||
}
|
||||
|
||||
unsigned membuffer_write_int24(membuffer * buf,uint32_t data)
|
||||
{
|
||||
uint8_t temp[3] = {(uint8_t)(data>>16),(uint8_t)(data>>8),(uint8_t)data};
|
||||
return membuffer_write_data(buf,temp,3);
|
||||
}
|
||||
|
||||
unsigned membuffer_write_int16(membuffer * buf,uint16_t data)
|
||||
{
|
||||
uint8_t temp[2] = {(uint8_t)(data>>8),(uint8_t)data};
|
||||
return membuffer_write_data(buf,temp,2);
|
||||
}
|
||||
|
||||
unsigned membuffer_write_atom_name(membuffer * buf,const char * data)
|
||||
{
|
||||
return membuffer_write_data(buf,data,4)==4 ? 1 : 0;
|
||||
}
|
||||
|
||||
void membuffer_write_atom(membuffer * buf,const char * name,unsigned size,const void * data)
|
||||
{
|
||||
membuffer_write_int32(buf,size + 8);
|
||||
membuffer_write_atom_name(buf,name);
|
||||
membuffer_write_data(buf,data,size);
|
||||
}
|
||||
|
||||
unsigned membuffer_write_string(membuffer * buf,const char * data)
|
||||
{
|
||||
return membuffer_write_data(buf,data,strlen(data));
|
||||
}
|
||||
|
||||
unsigned membuffer_write_int8(membuffer * buf,uint8_t data)
|
||||
{
|
||||
return membuffer_write_data(buf,&data,1);
|
||||
}
|
||||
|
||||
void * membuffer_get_ptr(const membuffer * buf)
|
||||
{
|
||||
return buf->data;
|
||||
}
|
||||
|
||||
unsigned membuffer_get_size(const membuffer * buf)
|
||||
{
|
||||
return buf->written;
|
||||
}
|
||||
|
||||
unsigned membuffer_error(const membuffer * buf)
|
||||
{
|
||||
return buf->error;
|
||||
}
|
||||
|
||||
void membuffer_set_error(membuffer * buf) {buf->error = 1;}
|
||||
|
||||
unsigned membuffer_transfer_from_file(membuffer * buf,mp4ff_t * src,unsigned bytes)
|
||||
{
|
||||
unsigned oldsize;
|
||||
void * bufptr;
|
||||
|
||||
oldsize = membuffer_get_size(buf);
|
||||
if (membuffer_write_data(buf,0,bytes) != bytes) return 0;
|
||||
|
||||
bufptr = membuffer_get_ptr(buf);
|
||||
if (bufptr==0) return 0;
|
||||
|
||||
if ((unsigned)mp4ff_read_data(src,(char*)bufptr + oldsize,bytes)!=bytes)
|
||||
{
|
||||
membuffer_set_error(buf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return bytes;
|
||||
}
|
||||
|
||||
|
||||
membuffer * membuffer_create()
|
||||
{
|
||||
const unsigned initial_size = 256;
|
||||
|
||||
membuffer * buf = (membuffer *) malloc(sizeof(membuffer));
|
||||
buf->data = malloc(initial_size);
|
||||
buf->written = 0;
|
||||
buf->allocated = initial_size;
|
||||
buf->error = buf->data == 0 ? 1 : 0;
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
void membuffer_free(membuffer * buf)
|
||||
{
|
||||
if (buf->data) free(buf->data);
|
||||
free(buf);
|
||||
}
|
||||
|
||||
void * membuffer_detach(membuffer * buf)
|
||||
{
|
||||
void * ret;
|
||||
|
||||
if (buf->error) return 0;
|
||||
|
||||
ret = realloc(buf->data,buf->written);
|
||||
|
||||
if (ret == 0) free(buf->data);
|
||||
|
||||
buf->data = 0;
|
||||
buf->error = 1;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* metadata tag structure */
|
||||
typedef struct
|
||||
{
|
||||
char *item;
|
||||
char *value;
|
||||
} mp4ff_tag_t;
|
||||
|
||||
/* metadata list structure */
|
||||
typedef struct
|
||||
{
|
||||
mp4ff_tag_t *tags;
|
||||
uint32_t count;
|
||||
} mp4ff_metadata_t;
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
{
|
||||
const char * atom;
|
||||
const char * name;
|
||||
} stdmeta_entry;
|
||||
|
||||
static stdmeta_entry stdmetas[] =
|
||||
{
|
||||
{"©nam","title"},
|
||||
{"©ART","artist"},
|
||||
{"©wrt","writer"},
|
||||
{"©alb","album"},
|
||||
{"©day","date"},
|
||||
{"©too","tool"},
|
||||
{"©cmt","comment"},
|
||||
// {"©gen","genre"},
|
||||
{"cpil","compilation"},
|
||||
// {"trkn","track"},
|
||||
// {"disk","disc"},
|
||||
// {"gnre","genre"},
|
||||
{"covr","cover"},
|
||||
};
|
||||
|
||||
|
||||
static const char* find_standard_meta(const char * name) //returns atom name if found, 0 if not
|
||||
{
|
||||
unsigned n;
|
||||
for(n=0;n<sizeof(stdmetas)/sizeof(stdmetas[0]);n++)
|
||||
{
|
||||
if (!stricmp(name,stdmetas[n].name)) return stdmetas[n].atom;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void membuffer_write_track_tag(membuffer * buf,const char * name,uint32_t index,uint32_t total)
|
||||
{
|
||||
membuffer_write_int32(buf,8 /*atom header*/ + 8 /*data atom header*/ + 8 /*flags + reserved*/ + 8 /*actual data*/ );
|
||||
membuffer_write_atom_name(buf,name);
|
||||
membuffer_write_int32(buf,8 /*data atom header*/ + 8 /*flags + reserved*/ + 8 /*actual data*/ );
|
||||
membuffer_write_atom_name(buf,"data");
|
||||
membuffer_write_int32(buf,0);//flags
|
||||
membuffer_write_int32(buf,0);//reserved
|
||||
membuffer_write_int16(buf,0);
|
||||
membuffer_write_int16(buf,(uint16_t)index);//track number
|
||||
membuffer_write_int16(buf,(uint16_t)total);//total tracks
|
||||
membuffer_write_int16(buf,0);
|
||||
}
|
||||
|
||||
static void membuffer_write_int16_tag(membuffer * buf,const char * name,uint16_t value)
|
||||
{
|
||||
membuffer_write_int32(buf,8 /*atom header*/ + 8 /*data atom header*/ + 8 /*flags + reserved*/ + 2 /*actual data*/ );
|
||||
membuffer_write_atom_name(buf,name);
|
||||
membuffer_write_int32(buf,8 /*data atom header*/ + 8 /*flags + reserved*/ + 2 /*actual data*/ );
|
||||
membuffer_write_atom_name(buf,"data");
|
||||
membuffer_write_int32(buf,0);//flags
|
||||
membuffer_write_int32(buf,0);//reserved
|
||||
membuffer_write_int16(buf,value);//value
|
||||
}
|
||||
|
||||
static void membuffer_write_std_tag(membuffer * buf,const char * name,const char * value)
|
||||
{
|
||||
membuffer_write_int32(buf,8 /*atom header*/ + 8 /*data atom header*/ + 8 /*flags + reserved*/ + strlen(value) );
|
||||
membuffer_write_atom_name(buf,name);
|
||||
membuffer_write_int32(buf,8 /*data atom header*/ + 8 /*flags + reserved*/ + strlen(value));
|
||||
membuffer_write_atom_name(buf,"data");
|
||||
membuffer_write_int32(buf,1);//flags
|
||||
membuffer_write_int32(buf,0);//reserved
|
||||
membuffer_write_data(buf,value,strlen(value));
|
||||
}
|
||||
|
||||
static void membuffer_write_custom_tag(membuffer * buf,const char * name,const char * value)
|
||||
{
|
||||
membuffer_write_int32(buf,8 /*atom header*/ + 0x1C /*weirdo itunes atom*/ + 12 /*name atom header*/ + strlen(name) + 16 /*data atom header + flags*/ + strlen(value) );
|
||||
membuffer_write_atom_name(buf,"----");
|
||||
membuffer_write_int32(buf,0x1C);//weirdo itunes atom
|
||||
membuffer_write_atom_name(buf,"mean");
|
||||
membuffer_write_int32(buf,0);
|
||||
membuffer_write_data(buf,"com.apple.iTunes",16);
|
||||
membuffer_write_int32(buf,12 + strlen(name));
|
||||
membuffer_write_atom_name(buf,"name");
|
||||
membuffer_write_int32(buf,0);
|
||||
membuffer_write_data(buf,name,strlen(name));
|
||||
membuffer_write_int32(buf,8 /*data atom header*/ + 8 /*flags + reserved*/ + strlen(value));
|
||||
membuffer_write_atom_name(buf,"data");
|
||||
membuffer_write_int32(buf,1);//flags
|
||||
membuffer_write_int32(buf,0);//reserved
|
||||
membuffer_write_data(buf,value,strlen(value));
|
||||
|
||||
}
|
||||
|
||||
static uint32_t myatoi(const char * param)
|
||||
{
|
||||
return param ? atoi(param) : 0;
|
||||
}
|
||||
|
||||
static uint32_t create_ilst(const mp4ff_metadata_t * data,void ** out_buffer,uint32_t * out_size)
|
||||
{
|
||||
membuffer * buf = membuffer_create();
|
||||
unsigned metaptr;
|
||||
char * mask = (char*)malloc(data->count);
|
||||
memset(mask,0,data->count);
|
||||
|
||||
{
|
||||
const char * tracknumber_ptr = 0, * totaltracks_ptr = 0;
|
||||
const char * discnumber_ptr = 0, * totaldiscs_ptr = 0;
|
||||
const char * genre_ptr = 0, * tempo_ptr = 0;
|
||||
for(metaptr = 0; metaptr < data->count; metaptr++)
|
||||
{
|
||||
mp4ff_tag_t * tag = &data->tags[metaptr];
|
||||
if (!stricmp(tag->item,"tracknumber") || !stricmp(tag->item,"track"))
|
||||
{
|
||||
if (tracknumber_ptr==0) tracknumber_ptr = tag->value;
|
||||
mask[metaptr] = 1;
|
||||
}
|
||||
else if (!stricmp(tag->item,"totaltracks"))
|
||||
{
|
||||
if (totaltracks_ptr==0) totaltracks_ptr = tag->value;
|
||||
mask[metaptr] = 1;
|
||||
}
|
||||
else if (!stricmp(tag->item,"discnumber") || !stricmp(tag->item,"disc"))
|
||||
{
|
||||
if (discnumber_ptr==0) discnumber_ptr = tag->value;
|
||||
mask[metaptr] = 1;
|
||||
}
|
||||
else if (!stricmp(tag->item,"totaldiscs"))
|
||||
{
|
||||
if (totaldiscs_ptr==0) totaldiscs_ptr = tag->value;
|
||||
mask[metaptr] = 1;
|
||||
}
|
||||
else if (!stricmp(tag->item,"genre"))
|
||||
{
|
||||
if (genre_ptr==0) genre_ptr = tag->value;
|
||||
mask[metaptr] = 1;
|
||||
}
|
||||
else if (!stricmp(tag->item,"tempo"))
|
||||
{
|
||||
if (tempo_ptr==0) tempo_ptr = tag->value;
|
||||
mask[metaptr] = 1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (tracknumber_ptr) membuffer_write_track_tag(buf,"trkn",myatoi(tracknumber_ptr),myatoi(totaltracks_ptr));
|
||||
if (discnumber_ptr) membuffer_write_track_tag(buf,"disk",myatoi(discnumber_ptr),myatoi(totaldiscs_ptr));
|
||||
if (tempo_ptr) membuffer_write_int16_tag(buf,"tmpo",(uint16_t)myatoi(tempo_ptr));
|
||||
|
||||
if (genre_ptr)
|
||||
{
|
||||
uint32_t index = mp4ff_meta_genre_to_index(genre_ptr);
|
||||
if (index==0)
|
||||
membuffer_write_std_tag(buf,"©gen",genre_ptr);
|
||||
else
|
||||
membuffer_write_int16_tag(buf,"gnre",(uint16_t)index);
|
||||
}
|
||||
}
|
||||
|
||||
for(metaptr = 0; metaptr < data->count; metaptr++)
|
||||
{
|
||||
if (!mask[metaptr])
|
||||
{
|
||||
mp4ff_tag_t * tag = &data->tags[metaptr];
|
||||
const char * std_meta_atom = find_standard_meta(tag->item);
|
||||
if (std_meta_atom)
|
||||
{
|
||||
membuffer_write_std_tag(buf,std_meta_atom,tag->value);
|
||||
}
|
||||
else
|
||||
{
|
||||
membuffer_write_custom_tag(buf,tag->item,tag->value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
free(mask);
|
||||
|
||||
if (membuffer_error(buf))
|
||||
{
|
||||
membuffer_free(buf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
*out_size = membuffer_get_size(buf);
|
||||
*out_buffer = membuffer_detach(buf);
|
||||
membuffer_free(buf);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static uint32_t find_atom(mp4ff_t * f,uint64_t base,uint32_t size,const char * name)
|
||||
{
|
||||
uint32_t remaining = size;
|
||||
uint64_t atom_offset = base;
|
||||
for(;;)
|
||||
{
|
||||
char atom_name[4];
|
||||
uint32_t atom_size;
|
||||
|
||||
mp4ff_set_position(f,atom_offset);
|
||||
|
||||
if (remaining < 8) break;
|
||||
atom_size = mp4ff_read_int32(f);
|
||||
if (atom_size > remaining || atom_size < 8) break;
|
||||
mp4ff_read_data(f,atom_name,4);
|
||||
|
||||
if (!memcmp(atom_name,name,4))
|
||||
{
|
||||
mp4ff_set_position(f,atom_offset);
|
||||
return 1;
|
||||
}
|
||||
|
||||
remaining -= atom_size;
|
||||
atom_offset += atom_size;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint32_t find_atom_v2(mp4ff_t * f,uint64_t base,uint32_t size,const char * name,uint32_t extraheaders,const char * name_inside)
|
||||
{
|
||||
uint64_t first_base = (uint64_t)(-1);
|
||||
while(find_atom(f,base,size,name))//try to find atom <name> with atom <name_inside> in it
|
||||
{
|
||||
uint64_t mybase = mp4ff_position(f);
|
||||
uint32_t mysize = mp4ff_read_int32(f);
|
||||
|
||||
if (first_base == (uint64_t)(-1)) first_base = mybase;
|
||||
|
||||
if (mysize < 8 + extraheaders) break;
|
||||
|
||||
if (find_atom(f,mybase+(8+extraheaders),mysize-(8+extraheaders),name_inside))
|
||||
{
|
||||
mp4ff_set_position(f,mybase);
|
||||
return 2;
|
||||
}
|
||||
base += mysize;
|
||||
if (size<=mysize) {size=0;break;}
|
||||
size -= mysize;
|
||||
}
|
||||
|
||||
if (first_base != (uint64_t)(-1))//wanted atom inside not found
|
||||
{
|
||||
mp4ff_set_position(f,first_base);
|
||||
return 1;
|
||||
}
|
||||
else return 0;
|
||||
}
|
||||
|
||||
static uint32_t create_meta(const mp4ff_metadata_t * data,void ** out_buffer,uint32_t * out_size)
|
||||
{
|
||||
membuffer * buf;
|
||||
uint32_t ilst_size;
|
||||
void * ilst_buffer;
|
||||
|
||||
if (!create_ilst(data,&ilst_buffer,&ilst_size)) return 0;
|
||||
|
||||
buf = membuffer_create();
|
||||
|
||||
membuffer_write_int32(buf,0);
|
||||
membuffer_write_atom(buf,"ilst",ilst_size,ilst_buffer);
|
||||
free(ilst_buffer);
|
||||
|
||||
*out_size = membuffer_get_size(buf);
|
||||
*out_buffer = membuffer_detach(buf);
|
||||
membuffer_free(buf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static uint32_t create_udta(const mp4ff_metadata_t * data,void ** out_buffer,uint32_t * out_size)
|
||||
{
|
||||
membuffer * buf;
|
||||
uint32_t meta_size;
|
||||
void * meta_buffer;
|
||||
|
||||
if (!create_meta(data,&meta_buffer,&meta_size)) return 0;
|
||||
|
||||
buf = membuffer_create();
|
||||
|
||||
membuffer_write_atom(buf,"meta",meta_size,meta_buffer);
|
||||
|
||||
free(meta_buffer);
|
||||
|
||||
*out_size = membuffer_get_size(buf);
|
||||
*out_buffer = membuffer_detach(buf);
|
||||
membuffer_free(buf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static uint32_t modify_moov(mp4ff_t * f,const mp4ff_metadata_t * data,void ** out_buffer,uint32_t * out_size)
|
||||
{
|
||||
uint64_t total_base = f->moov_offset + 8;
|
||||
uint32_t total_size = (uint32_t)(f->moov_size - 8);
|
||||
|
||||
uint64_t udta_offset,meta_offset,ilst_offset;
|
||||
uint32_t udta_size, meta_size, ilst_size;
|
||||
|
||||
uint32_t new_ilst_size;
|
||||
void * new_ilst_buffer;
|
||||
|
||||
uint8_t * p_out;
|
||||
int32_t size_delta;
|
||||
|
||||
|
||||
if (!find_atom_v2(f,total_base,total_size,"udta",0,"meta"))
|
||||
{
|
||||
membuffer * buf;
|
||||
void * new_udta_buffer;
|
||||
uint32_t new_udta_size;
|
||||
if (!create_udta(data,&new_udta_buffer,&new_udta_size)) return 0;
|
||||
|
||||
buf = membuffer_create();
|
||||
mp4ff_set_position(f,total_base);
|
||||
membuffer_transfer_from_file(buf,f,total_size);
|
||||
|
||||
membuffer_write_atom(buf,"udta",new_udta_size,new_udta_buffer);
|
||||
|
||||
free(new_udta_buffer);
|
||||
|
||||
*out_size = membuffer_get_size(buf);
|
||||
*out_buffer = membuffer_detach(buf);
|
||||
membuffer_free(buf);
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
udta_offset = mp4ff_position(f);
|
||||
udta_size = mp4ff_read_int32(f);
|
||||
if (find_atom_v2(f,udta_offset+8,udta_size-8,"meta",4,"ilst")<2)
|
||||
{
|
||||
membuffer * buf;
|
||||
void * new_meta_buffer;
|
||||
uint32_t new_meta_size;
|
||||
if (!create_meta(data,&new_meta_buffer,&new_meta_size)) return 0;
|
||||
|
||||
buf = membuffer_create();
|
||||
mp4ff_set_position(f,total_base);
|
||||
membuffer_transfer_from_file(buf,f,(uint32_t)(udta_offset - total_base));
|
||||
|
||||
membuffer_write_int32(buf,udta_size + 8 + new_meta_size);
|
||||
membuffer_write_atom_name(buf,"udta");
|
||||
membuffer_transfer_from_file(buf,f,udta_size);
|
||||
|
||||
membuffer_write_atom(buf,"meta",new_meta_size,new_meta_buffer);
|
||||
free(new_meta_buffer);
|
||||
|
||||
*out_size = membuffer_get_size(buf);
|
||||
*out_buffer = membuffer_detach(buf);
|
||||
membuffer_free(buf);
|
||||
return 1;
|
||||
}
|
||||
meta_offset = mp4ff_position(f);
|
||||
meta_size = mp4ff_read_int32(f);
|
||||
if (!find_atom(f,meta_offset+12,meta_size-12,"ilst")) return 0;//shouldn't happen, find_atom_v2 above takes care of it
|
||||
ilst_offset = mp4ff_position(f);
|
||||
ilst_size = mp4ff_read_int32(f);
|
||||
|
||||
if (!create_ilst(data,&new_ilst_buffer,&new_ilst_size)) return 0;
|
||||
|
||||
size_delta = new_ilst_size - (ilst_size - 8);
|
||||
|
||||
*out_size = total_size + size_delta;
|
||||
*out_buffer = malloc(*out_size);
|
||||
if (*out_buffer == 0)
|
||||
{
|
||||
free(new_ilst_buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
p_out = (uint8_t*)*out_buffer;
|
||||
|
||||
mp4ff_set_position(f,total_base);
|
||||
mp4ff_read_data(f,p_out,(uint32_t)(udta_offset - total_base )); p_out += (uint32_t)(udta_offset - total_base );
|
||||
*(uint32_t*)p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); p_out += 4;
|
||||
mp4ff_read_data(f,p_out,4); p_out += 4;
|
||||
mp4ff_read_data(f,p_out,(uint32_t)(meta_offset - udta_offset - 8)); p_out += (uint32_t)(meta_offset - udta_offset - 8);
|
||||
*(uint32_t*)p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); p_out += 4;
|
||||
mp4ff_read_data(f,p_out,4); p_out += 4;
|
||||
mp4ff_read_data(f,p_out,(uint32_t)(ilst_offset - meta_offset - 8)); p_out += (uint32_t)(ilst_offset - meta_offset - 8);
|
||||
*(uint32_t*)p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); p_out += 4;
|
||||
mp4ff_read_data(f,p_out,4); p_out += 4;
|
||||
|
||||
memcpy(p_out,new_ilst_buffer,new_ilst_size);
|
||||
p_out += new_ilst_size;
|
||||
|
||||
mp4ff_set_position(f,ilst_offset + ilst_size);
|
||||
mp4ff_read_data(f,p_out,(uint32_t)(total_size - (ilst_offset - total_base) - ilst_size));
|
||||
|
||||
free(new_ilst_buffer);
|
||||
}
|
||||
return 1;
|
||||
|
||||
}
|
||||
|
||||
int32_t mp4ff_meta_update(mp4ff_callback_t *f,const mp4ff_metadata_t * data)
|
||||
{
|
||||
void * new_moov_data;
|
||||
uint32_t new_moov_size;
|
||||
|
||||
mp4ff_t *ff = malloc(sizeof(mp4ff_t));
|
||||
|
||||
memset(ff, 0, sizeof(mp4ff_t));
|
||||
ff->stream = f;
|
||||
mp4ff_set_position(ff,0);
|
||||
|
||||
parse_atoms(ff);
|
||||
|
||||
|
||||
if (!modify_moov(ff,data,&new_moov_data,&new_moov_size))
|
||||
{
|
||||
mp4ff_close(ff);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* copy moov atom to end of the file */
|
||||
if (ff->last_atom != ATOM_MOOV)
|
||||
{
|
||||
char *free_data = "free";
|
||||
|
||||
/* rename old moov to free */
|
||||
mp4ff_set_position(ff, ff->moov_offset + 4);
|
||||
mp4ff_write_data(ff, free_data, 4);
|
||||
|
||||
mp4ff_set_position(ff, ff->file_size);
|
||||
mp4ff_write_int32(ff,new_moov_size + 8);
|
||||
mp4ff_write_data(ff,"moov",4);
|
||||
mp4ff_write_data(ff, new_moov_data, new_moov_size);
|
||||
}
|
||||
else
|
||||
{
|
||||
mp4ff_set_position(ff, ff->moov_offset);
|
||||
mp4ff_write_int32(ff,new_moov_size + 8);
|
||||
mp4ff_write_data(ff,"moov",4);
|
||||
mp4ff_write_data(ff, new_moov_data, new_moov_size);
|
||||
}
|
||||
|
||||
mp4ff_truncate(ff);
|
||||
|
||||
mp4ff_close(ff);
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -0,0 +1,188 @@
|
|||
/*
|
||||
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
||||
** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
|
||||
**
|
||||
** This program is free software; you can redistribute it and/or modify
|
||||
** it under the terms of the GNU General Public License as published by
|
||||
** the Free Software Foundation; either version 2 of the License, or
|
||||
** (at your option) any later version.
|
||||
**
|
||||
** This program is distributed in the hope that it will be useful,
|
||||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
** GNU General Public License for more details.
|
||||
**
|
||||
** You should have received a copy of the GNU General Public License
|
||||
** along with this program; if not, write to the Free Software
|
||||
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
**
|
||||
** Any non-GPL usage of this software or parts of this software is strictly
|
||||
** forbidden.
|
||||
**
|
||||
** Commercial non-GPL licensing of this software is possible.
|
||||
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
||||
**
|
||||
** $Id: mp4util.c,v 1.15 2004/01/11 15:52:19 menno Exp $
|
||||
**/
|
||||
|
||||
#include "mp4ffint.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
int32_t mp4ff_read_data(mp4ff_t *f, int8_t *data, uint32_t size)
|
||||
{
|
||||
int32_t result = 1;
|
||||
|
||||
result = f->stream->read(f->stream->user_data, data, size);
|
||||
|
||||
f->current_position += size;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int32_t mp4ff_truncate(mp4ff_t * f)
|
||||
{
|
||||
return f->stream->truncate(f->stream->user_data);
|
||||
}
|
||||
|
||||
int32_t mp4ff_write_data(mp4ff_t *f, int8_t *data, uint32_t size)
|
||||
{
|
||||
int32_t result = 1;
|
||||
|
||||
result = f->stream->write(f->stream->user_data, data, size);
|
||||
|
||||
f->current_position += size;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int32_t mp4ff_write_int32(mp4ff_t *f,const uint32_t data)
|
||||
{
|
||||
uint32_t result;
|
||||
uint32_t a, b, c, d;
|
||||
int8_t temp[4];
|
||||
|
||||
*(uint32_t*)temp = data;
|
||||
a = (uint8_t)temp[0];
|
||||
b = (uint8_t)temp[1];
|
||||
c = (uint8_t)temp[2];
|
||||
d = (uint8_t)temp[3];
|
||||
|
||||
result = (a<<24) | (b<<16) | (c<<8) | d;
|
||||
|
||||
return mp4ff_write_data(f,(uint8_t*)&result,sizeof(result));
|
||||
}
|
||||
|
||||
int32_t mp4ff_set_position(mp4ff_t *f, const int64_t position)
|
||||
{
|
||||
f->stream->seek(f->stream->user_data, position);
|
||||
f->current_position = position;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int64_t mp4ff_position(const mp4ff_t *f)
|
||||
{
|
||||
return f->current_position;
|
||||
}
|
||||
|
||||
uint64_t mp4ff_read_int64(mp4ff_t *f)
|
||||
{
|
||||
uint8_t data[8];
|
||||
uint64_t result = 0;
|
||||
int8_t i;
|
||||
|
||||
mp4ff_read_data(f, data, 8);
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
result |= ((uint64_t)data[i]) << ((7 - i) * 8);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
uint32_t mp4ff_read_int32(mp4ff_t *f)
|
||||
{
|
||||
uint32_t result;
|
||||
uint32_t a, b, c, d;
|
||||
int8_t data[4];
|
||||
|
||||
mp4ff_read_data(f, data, 4);
|
||||
a = (uint8_t)data[0];
|
||||
b = (uint8_t)data[1];
|
||||
c = (uint8_t)data[2];
|
||||
d = (uint8_t)data[3];
|
||||
|
||||
result = (a<<24) | (b<<16) | (c<<8) | d;
|
||||
return (uint32_t)result;
|
||||
}
|
||||
|
||||
uint32_t mp4ff_read_int24(mp4ff_t *f)
|
||||
{
|
||||
uint32_t result;
|
||||
uint32_t a, b, c;
|
||||
int8_t data[4];
|
||||
|
||||
mp4ff_read_data(f, data, 3);
|
||||
a = (uint8_t)data[0];
|
||||
b = (uint8_t)data[1];
|
||||
c = (uint8_t)data[2];
|
||||
|
||||
result = (a<<16) | (b<<8) | c;
|
||||
return (uint32_t)result;
|
||||
}
|
||||
|
||||
uint16_t mp4ff_read_int16(mp4ff_t *f)
|
||||
{
|
||||
uint32_t result;
|
||||
uint32_t a, b;
|
||||
int8_t data[2];
|
||||
|
||||
mp4ff_read_data(f, data, 2);
|
||||
a = (uint8_t)data[0];
|
||||
b = (uint8_t)data[1];
|
||||
|
||||
result = (a<<8) | b;
|
||||
return (uint16_t)result;
|
||||
}
|
||||
|
||||
char * mp4ff_read_string(mp4ff_t * f,uint32_t length)
|
||||
{
|
||||
char * str = (char*)malloc(length + 1);
|
||||
if (str!=0)
|
||||
{
|
||||
if ((uint32_t)mp4ff_read_data(f,str,length)!=length)
|
||||
{
|
||||
free(str);
|
||||
str = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
str[length] = 0;
|
||||
}
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
uint8_t mp4ff_read_char(mp4ff_t *f)
|
||||
{
|
||||
uint8_t output;
|
||||
mp4ff_read_data(f, &output, 1);
|
||||
return output;
|
||||
}
|
||||
|
||||
uint32_t mp4ff_read_mp4_descr_length(mp4ff_t *f)
|
||||
{
|
||||
uint8_t b;
|
||||
uint8_t numBytes = 0;
|
||||
uint32_t length = 0;
|
||||
|
||||
do
|
||||
{
|
||||
b = mp4ff_read_char(f);
|
||||
numBytes++;
|
||||
length = (length << 7) | (b & 0x7F);
|
||||
} while ((b & 0x80) && numBytes < 4);
|
||||
|
||||
return length;
|
||||
}
|
||||
Loading…
Reference in New Issue