[pspplayer commit] r610 - in trunk: Noxa.Emulation.Psp.Video.ManagedGL Tests/avcdecodetest Tests/avcdecodetest/Binar...

[codesite...@google.com]

Author: ben.vanik
Date: Sun Apr 6 05:36:03 2008
New Revision: 610

Added:
trunk/Tests/avcdecodetest/
trunk/Tests/avcdecodetest/Binaries/
trunk/Tests/avcdecodetest/Binaries/EBOOT.PBP (contents, props changed)
trunk/Tests/avcdecodetest/Binaries/mpeg_vsh330.prx (contents, props changed)
trunk/Tests/avcdecodetest/Makefile
trunk/Tests/avcdecodetest/Makefile3xx
trunk/Tests/avcdecodetest/main.c
trunk/Tests/avcdecodetest/mem64.c
trunk/Tests/avcdecodetest/mem64.h
trunk/Tests/avcdecodetest/mp4ff/
trunk/Tests/avcdecodetest/mp4ff/Makefile
trunk/Tests/avcdecodetest/mp4ff/include/
trunk/Tests/avcdecodetest/mp4ff/include/config.h
trunk/Tests/avcdecodetest/mp4ff/include/drms.h
trunk/Tests/avcdecodetest/mp4ff/include/drmstables.h
trunk/Tests/avcdecodetest/mp4ff/include/mp4ff.h
trunk/Tests/avcdecodetest/mp4ff/include/mp4ff_int_types.h
trunk/Tests/avcdecodetest/mp4ff/include/mp4ffint.h
trunk/Tests/avcdecodetest/mp4ff/src/
trunk/Tests/avcdecodetest/mp4ff/src/Makefile
trunk/Tests/avcdecodetest/mp4ff/src/drms.c
trunk/Tests/avcdecodetest/mp4ff/src/mp4atom.c
trunk/Tests/avcdecodetest/mp4ff/src/mp4ff.c
trunk/Tests/avcdecodetest/mp4ff/src/mp4meta.c
trunk/Tests/avcdecodetest/mp4ff/src/mp4sample.c
trunk/Tests/avcdecodetest/mp4ff/src/mp4tagupdate.c
trunk/Tests/avcdecodetest/mp4ff/src/mp4util.c
trunk/Tests/avcdecodetest/mpegbase.S
trunk/Tests/avcdecodetest/pspmpeg/
trunk/Tests/avcdecodetest/pspmpeg/Makefile
trunk/Tests/avcdecodetest/pspmpeg/pspmpeg.h
trunk/Tests/avcdecodetest/pspmpeg/sceMpeg.S
Modified:
trunk/Noxa.Emulation.Psp.Video.ManagedGL/MGLDriver.Worker.cs

Log:
working test from cooleyes - now just need to get the emu skipping it

Modified: trunk/Noxa.Emulation.Psp.Video.ManagedGL/MGLDriver.Worker.cs
==============================================================================
--- trunk/Noxa.Emulation.Psp.Video.ManagedGL/MGLDriver.Worker.cs (original)
+++ trunk/Noxa.Emulation.Psp.Video.ManagedGL/MGLDriver.Worker.cs Sun Apr 6 05:36:03 2008
@@ -27,7 +27,7 @@
// We need to ensure that vsync is always 'running'
// For now, we just fake this timer stuff so that the vcount goes up every 16ms
// HACK: longer duration so the cpu isn't pegged firing interrupts
- _vsyncTimer = _timerQueue.CreatePeriodicTimer( new TimerCallback( VsyncTimer ), 32, TimerExecutionContext.TimerThread, false );
+ _vsyncTimer = _timerQueue.CreatePeriodicTimer( new TimerCallback( VsyncTimer ), 320, TimerExecutionContext.TimerThread, false );
}

private void VsyncTimer( Timer timer )
@@ -36,8 +36,8 @@
_vsyncWaiting = true;

// HACK: this should happen in NextFrame()
- //lock( this )
- // this.Emu.Cpu.SetPendingInterrupt( 30 );
+ lock( this )
+ this.Emu.Cpu.SetPendingInterrupt( 30 );
}

#region Frame Advancement

Added: trunk/Tests/avcdecodetest/Binaries/EBOOT.PBP
==============================================================================
Binary file. No diff available.

Added: trunk/Tests/avcdecodetest/Binaries/mpeg_vsh330.prx
==============================================================================
Binary file. No diff available.

Added: trunk/Tests/avcdecodetest/Makefile
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/Makefile Sun Apr 6 05:36:03 2008
@@ -0,0 +1,6 @@
+fw3xx:
+ make -f Makefile3xx
+ cp -f EBOOT.PBP AvcDecodeTest
+
+clean:
+ make -f Makefile3xx clean
\ No newline at end of file

Added: trunk/Tests/avcdecodetest/Makefile3xx
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/Makefile3xx Sun Apr 6 05:36:03 2008
@@ -0,0 +1,20 @@
+TARGET = AvcDecodeTest
+OBJS = main.o mem64.o mpegbase.o
+
+BUILD_PRX = 1
+PSP_FW_VERSION=371
+
+CFLAGS = -G0 -Wall -O2
+CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
+ASFLAGS = $(CFLAGS)
+
+INCDIR = ./mp4ff/include
+LIBDIR = .
+LDFLAGS =
+LIBS= -lpsppower -lm -lpsprtc -lpspgu -lpspmpeg -lmp4ff
+
+EXTRA_TARGETS = EBOOT.PBP
+PSP_EBOOT_TITLE = AvcDecode Test
+
+PSPSDK=$(shell psp-config --pspsdk-path)
+include $(PSPSDK)/lib/build.mak

Added: trunk/Tests/avcdecodetest/main.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/main.c Sun Apr 6 05:36:03 2008
@@ -0,0 +1,469 @@
+/*
+ * Copyright (C) 2008 cooleyes
+ * eyes.c...@gmail.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, 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 GNU Make; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+#include <pspkernel.h>
+#include <pspctrl.h>
+#include <pspdisplay.h>
+#include <psputils.h>
+#include <pspgu.h>
+#include <pspdebug.h>
+#include <psppower.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <psprtc.h>
+#include <pspsdk.h>
+#include <string.h>
+#include <malloc.h>
+#include "mem64.h"
+#include "pspmpeg/pspmpeg.h"
+#include "mp4ff.h"
+
+int SetupCallbacks();
+
+PSP_MODULE_INFO("avcdecode test", 0, 1, 1);
+PSP_MAIN_THREAD_ATTR(0);
+PSP_HEAP_SIZE_KB(18*1024);
+
+SceCtrlData input;
+
+typedef struct {
+ ScePVoid sps_buffer;
+ SceInt32 sps_size;
+ ScePVoid pps_buffer;
+ SceInt32 pps_size;
+ SceInt32 unkown0;
+ ScePVoid nal_buffer;
+ SceInt32 nal_size;
+ SceInt32 mode;
+} AvcNalStruct;
+
+typedef struct {
+ SceInt32 unknown0;
+ SceInt32 unknown1;
+ SceInt32 width;
+ SceInt32 height;
+ SceInt32 unknown4;
+ SceInt32 unknown5;
+ SceInt32 unknown6;
+ SceInt32 unknown7;
+ SceInt32 unknown8;
+ SceInt32 unknown9;
+} AvcInfoStruct;
+
+typedef struct {
+ ScePVoid buffer0;
+ ScePVoid buffer1;
+ ScePVoid buffer2;
+ ScePVoid buffer3;
+ ScePVoid buffer4;
+ ScePVoid buffer5;
+ ScePVoid buffer6;
+ ScePVoid buffer7;
+ SceInt32 unknown0;
+ SceInt32 unknown1;
+ SceInt32 unknown2;
+} AvcYuvStruct;
+
+
+typedef struct {
+ SceInt32 unknown0;
+ SceInt32 unknown1;
+ SceInt32 unknown2;
+ SceInt32 unknown3;
+ AvcInfoStruct* info_buffer;
+ SceInt32 unknown5;
+ SceInt32 unknown6;
+ SceInt32 unknown7;
+ SceInt32 unknown8;
+ SceInt32 unknown9;
+ SceInt32 unknown10;
+ AvcYuvStruct* yuv_buffer;
+ SceInt32 unknown12;
+ SceInt32 unknown13;
+ SceInt32 unknown14;
+ SceInt32 unknown15;
+ SceInt32 unknown16;
+ SceInt32 unknown17;
+ SceInt32 unknown18;
+ SceInt32 unknown19;
+ SceInt32 unknown20;
+ SceInt32 unknown21;
+ SceInt32 unknown22;
+ SceInt32 unknown23;
+} AvcCodecStruct;
+
+typedef struct {
+ SceInt32 height;
+ SceInt32 width;
+ SceInt32 mode0;
+ SceInt32 mode1;
+ ScePVoid buffer0;
+ ScePVoid buffer1;
+ ScePVoid buffer2;
+ ScePVoid buffer3;
+ ScePVoid buffer4;
+ ScePVoid buffer5;
+ ScePVoid buffer6;
+ ScePVoid buffer7;
+} AvcCscStruct;
+
+typedef struct {
+ ScePVoid mpeg_buffer;
+ SceMpeg mpeg;
+ SceMpegRingbuffer mpeg_ringbuffer;
+ SceMpegAu* mpeg_au;
+ SceInt32 mpeg_mode;
+ SceInt32 mpeg_buffer_size;
+ ScePVoid mpeg_ddrtop;
+ ScePVoid mpeg_au_buffer;
+ AvcNalStruct mpeg_nal;
+ AvcCodecStruct* mpeg_codec_buffer;
+ AvcYuvStruct* mpeg_yuv_buffer;
+ AvcInfoStruct* mpeg_info_buffer;
+} AvcDecodeStruct;
+
+static uint32_t mp4_read(void *user_data, void *buffer, uint32_t length) {
+ FILE** fp = (FILE**)user_data;
+ uint32_t res = fread(buffer, length, 1, *fp);
+ return (res*length);
+}
+
+static uint32_t mp4_seek(void *user_data, uint64_t position) {
+ FILE** fp = (FILE**)user_data;
+ return fseek(*fp, position, PSP_SEEK_SET );
+}
+
+AvcDecodeStruct avc_struct;
+AvcDecodeStruct* avc = &avc_struct;
+AvcCscStruct csc_struct;
+AvcCscStruct* csc = &csc_struct;
+//unsigned char RGBBuffer[4*512*512];
+unsigned char RGBBuffer0[4*512*272];
+unsigned char RGBBuffer1[4*512*272];
+unsigned char* FrameBuffer[] = {RGBBuffer0, RGBBuffer1};
+int frame_index = 0;
+char filename[1024];
+
+mp4ff_callback_t mp4_callback = {mp4_read, 0, mp4_seek, 0, 0};
+
+int main(void)
+{
+ SetupCallbacks();
+
+ pspDebugScreenInit();
+ pspDebugScreenSetXY(0, 2);
+ //scePowerSetClockFrequency(333,333,166);
+ //scePowerSetCpuClockFrequency(333);
+ //scePowerSetBusClockFrequency(166);
+ scePowerSetClockFrequency(133,133,66);
+ scePowerSetCpuClockFrequency(133);
+ scePowerSetBusClockFrequency(66);
+ u32 cpu = scePowerGetCpuClockFrequency();
+ u32 bus = scePowerGetBusClockFrequency();
+
+ pspDebugScreenPrintf("cpu=%d, bus=%d\n", cpu, bus);
+
+ getcwd(filename, 256);
+ strcat(filename, "/mpeg_vsh330.prx");
+ pspDebugScreenPrintf("%s\n", filename);
+
+ FILE* mp4_file = fopen("ms0:/VIDEO/Test.MP4", "rb");
+ mp4_callback.user_data = &mp4_file;
+ mp4ff_t* mp4_handle = mp4ff_open_read(&mp4_callback);
+ u32 total_tracks = mp4ff_total_tracks(mp4_handle);
+ pspDebugScreenPrintf("total_tracks=%d\n", total_tracks);
+ int ii;
+ for(ii = 0; ii < total_tracks; ii++) {
+ pspDebugScreenPrintf("track%d : type 0x%08X\n", ii, mp4ff_get_track_type(mp4_handle, ii));
+ pspDebugScreenPrintf("track%d : %d samples\n", ii, mp4ff_num_samples(mp4_handle, ii));
+ }
+ u32 total_samples = mp4ff_num_samples(mp4_handle, 0);
+ unsigned char* sps_pps_buffer;
+ unsigned int sps_size, pps_size;
+
+ if ( mp4ff_get_avc_sps_pps(mp4_handle, 0, &sps_pps_buffer, &sps_size, &pps_size) != 0 || sps_size == 0 || pps_size == 0 ) {
+ pspDebugScreenPrintf("\nerr: get_avc_sps_pps\n");
+ goto wait;
+ }
+
+ //pspDebugScreenPrintf("sps_size=%d, pps_size=%d\n", sps_size, pps_size);
+
+ int result;
+ result = sceUtilityLoadAvModule(0);
+ if ( result < 0 ) {
+ pspDebugScreenPrintf("\nerr: sceUtilityLoadAvModule(0)\n");
+ goto wait;
+ }
+
+ SceUID modid;
+ int status;
+ modid = sceKernelLoadModule(filename, 0, NULL);
+ if(modid >= 0) {
+ modid = sceKernelStartModule(modid, 0, 0, &status, NULL);
+ }
+ else {
+ pspDebugScreenPrintf("\nerr=0x%08X : sceKernelLoadModule\n", modid);
+ goto wait;
+ }
+
+// result = pspSdkLoadStartModule("ms0:/mpeg_vsh330.prx", PSP_MEMORY_PARTITION_USER);
+// result = sceUtilityLoadAvModule(3);
+// if ( result < 0 ){
+// pspDebugScreenPrintf("\nerr=0x%08X : sceUtilityLoadAvModule(3)\n", result);
+// goto wait;
+// }
+
+ result = sceMpegInit();
+ if ( result != 0 ){
+ pspDebugScreenPrintf("\nerr: sceMpegInit\n");
+ goto wait;
+ }
+
+ avc->mpeg_mode = 4;
+// avc->mpeg_ddrtop = 0x09400000;
+// avc->mpeg_au_buffer = 0x09410000;
+ avc->mpeg_ddrtop = memalign(0x400000, 0x400000);
+ avc->mpeg_au_buffer = avc->mpeg_ddrtop + 0x10000;
+
+// pspDebugScreenPrintf("\naddress=0x%08X\n", avc->mpeg_au_buffer);
+
+
+ result = sceMpegQueryMemSize(avc->mpeg_mode);
+ if ( result < 0 ){
+ pspDebugScreenPrintf("\nerr: sceMpegQueryMemSize(0x%08X)\n", avc->mpeg_mode);
+ goto wait;
+ }
+
+// pspDebugScreenPrintf("\n%d\n", result);
+
+ avc->mpeg_buffer_size = result;
+
+ if ( (result & 0xF) != 0 )
+ result = (result & 0xFFFFFFF0) + 16;
+
+ avc->mpeg_buffer = malloc_64(result);
+ if ( avc->mpeg_buffer == 0 ) {
+ pspDebugScreenPrintf("\nerr: alloc\n");
+ goto wait;
+ }
+
+ result = sceMpegCreate(&avc->mpeg, avc->mpeg_buffer, avc->mpeg_buffer_size, &avc->mpeg_ringbuffer, 512, avc->mpeg_mode, avc->mpeg_ddrtop);
+ if ( result != 0){
+ pspDebugScreenPrintf("\nerr: sceMpegCreate\n");
+ goto wait;
+ }
+
+ avc->mpeg_au = (SceMpegAu*)malloc_64(64);
+ if ( avc->mpeg_au == 0 ) {
+ pspDebugScreenPrintf("\nerr: alloc\n");
+ goto wait;
+ }
+ memset(avc->mpeg_au, 0xFF, 64);
+ if ( sceMpegInitAu(&avc->mpeg, avc->mpeg_au_buffer, avc->mpeg_au) != 0 ){
+ pspDebugScreenPrintf("\nerr: sceMpegInitAu\n");
+ goto wait;
+ }
+
+ unsigned char* nal_buffer = (unsigned char*)malloc_64(1024*1024);
+
+// unsigned char sps_pps_buffer[27];
+//
+// FILE* fp;
+// fp = fopen("ms0:/sps_pps.dat", "rb");
+// fread(sps_pps_buffer, 27, 1, fp);
+// fclose(fp);
+// sps_size = 23;
+// pps_size = 4;
+
+ //---------------------------------------------------------------------------------//
+ float curr_ms = 1.0f;
+ u64 last_tick;
+ sceRtcGetCurrentTick(&last_tick);
+ u32 tick_frequency = sceRtcGetTickResolution();
+ int frame_count = 0;
+ sceCtrlReadBufferPositive(&input, 1);
+
+ int pic_num;
+
+ sceDisplayWaitVblankStart();
+ sceDisplaySetFrameBuf(FrameBuffer[frame_index], 512, PSP_DISPLAY_PIXEL_FORMAT_8888, PSP_DISPLAY_SETBUF_IMMEDIATE);
+
+while(!(input.Buttons & PSP_CTRL_TRIANGLE)) {
+
+ float curr_fps = 1.0f / curr_ms;
+ pspDebugScreenSetXY(0,0);
+ pspDebugScreenPrintf("fps: %d.%03d \n",(int)curr_fps,(int)((curr_fps-(int)curr_fps) * 1000.0f));
+
+ avc->mpeg_nal.sps_buffer = (&sps_pps_buffer[0]);
+ avc->mpeg_nal.sps_size = sps_size;
+ avc->mpeg_nal.pps_buffer = (&sps_pps_buffer[sps_size]);
+ avc->mpeg_nal.pps_size = pps_size;
+ avc->mpeg_nal.unkown0 = 4;
+ memset(nal_buffer, 0, 1024*1024);
+ mp4ff_read_sample_v2(mp4_handle, 0, frame_count, nal_buffer);
+ avc->mpeg_nal.nal_buffer = nal_buffer;
+ avc->mpeg_nal.nal_size = mp4ff_read_sample_getsize(mp4_handle, 0, frame_count);//size1 ;
+ if ( frame_count == 0 )
+ avc->mpeg_nal.mode = 3;
+ else
+ avc->mpeg_nal.mode = 0;
+ FILE* fp1;
+// memset(filename,0,1024);
+// sprintf(filename, "ms0:/mpeg%d_0.dat", frame_count);
+// fp1 = fopen(filename, "wb");
+// fwrite(p1, 512, 1, fp1);
+// fclose(fp1);
+
+ result = sceMpegGetAvcNalAu(&avc->mpeg, &avc->mpeg_nal, avc->mpeg_au);
+ memset(filename,0,1024);
+// sprintf(filename, "ms0:/au%d_1.dat", frame_count);
+// fp1 = fopen(filename, "wb");
+// fwrite(au0, 64, 1, fp1);
+// fclose(fp1);
+// pspDebugScreenPrintf(" GetAvcNalAu=0x%08X\n", result);
+
+ result = sceMpegAvcDecode(&avc->mpeg, avc->mpeg_au, 512, 0, &pic_num);
+// pspDebugScreenPrintf(" AvcDecode=0x%08X,0x%08X\n", result, pic_num);
+ result = sceMpegAvcDecodeDetail2(&avc->mpeg, &avc->mpeg_codec_buffer);
+// pspDebugScreenPrintf(" AvcDecodeDetail2=0x%08X\n", result);
+
+
+ if ( result == 0 ) {
+ avc->mpeg_yuv_buffer = avc->mpeg_codec_buffer->yuv_buffer;
+ avc->mpeg_info_buffer = avc->mpeg_codec_buffer->info_buffer;
+
+ if ( pic_num > 0 ) {
+ int i;
+ for(i=0;i<pic_num;i++) {
+ int csc_mode = 0;//i % 2;
+ csc->height = avc->mpeg_info_buffer->height >> 4;
+ csc->width = avc->mpeg_info_buffer->width >> 4;
+ csc->mode0 = csc_mode;
+ csc->mode1 = csc_mode;
+ if ( csc_mode == 0 ) {
+ csc->buffer0 = avc->mpeg_yuv_buffer->buffer0 ;
+ csc->buffer1 = avc->mpeg_yuv_buffer->buffer1 ;
+ csc->buffer2 = avc->mpeg_yuv_buffer->buffer2 ;
+ csc->buffer3 = avc->mpeg_yuv_buffer->buffer3 ;
+ csc->buffer4 = avc->mpeg_yuv_buffer->buffer4 ;
+ csc->buffer5 = avc->mpeg_yuv_buffer->buffer5 ;
+ csc->buffer6 = avc->mpeg_yuv_buffer->buffer6 ;
+ csc->buffer7 = avc->mpeg_yuv_buffer->buffer7 ;
+ }
+ else {
+ csc->buffer0 = avc->mpeg_yuv_buffer->buffer2 ;
+ csc->buffer1 = avc->mpeg_yuv_buffer->buffer3 ;
+ csc->buffer2 = avc->mpeg_yuv_buffer->buffer0 ;
+ csc->buffer3 = avc->mpeg_yuv_buffer->buffer1 ;
+ csc->buffer4 = avc->mpeg_yuv_buffer->buffer6 ;
+ csc->buffer5 = avc->mpeg_yuv_buffer->buffer7 ;
+ csc->buffer6 = avc->mpeg_yuv_buffer->buffer4 ;
+ csc->buffer7 = avc->mpeg_yuv_buffer->buffer5 ;
+ }
+
+ result = sceMpegBaseCscAvc(FrameBuffer[frame_index],0,512,csc);
+// pspDebugScreenPrintf(" BaseCscAvc=0x%08X\n", result);
+ if ( result == 0 ) {
+// memset(filename,0,1024);
+// sprintf(filename, "ms0:/RGB%d.%d.dat", frame_count,i);
+// fp1 = fopen(filename, "wb");
+// fwrite(RGBBuffer, 4*512*512, 1, fp1);
+// fclose(fp1);
+ sceDisplayWaitVblankStart();
+ sceDisplaySetFrameBuf(FrameBuffer[frame_index], 512, PSP_DISPLAY_PIXEL_FORMAT_8888, PSP_DISPLAY_SETBUF_IMMEDIATE);
+ frame_index = (frame_index+1) % 2;
+ //sceKernelDelayThread(10000);
+ }
+ }
+ }
+ }
+// memset(filename,0,1024);
+// sprintf(filename, "ms0:/mpeg%d.dat", frame_count);
+// fp1 = fopen(filename, "wb");
+// fwrite(p1, 512, 1, fp1);
+// fclose(fp1);
+ ++frame_count;
+ if ( frame_count >= total_samples )
+ break;
+ u64 curr_tick;
+ sceRtcGetCurrentTick(&curr_tick);
+ if ((curr_tick-last_tick) >= tick_frequency)
+ {
+ float time_span = ((int)(curr_tick-last_tick)) / (float)tick_frequency;
+ curr_ms = time_span / frame_count;
+ //frame_count = 0;
+ sceRtcGetCurrentTick(&last_tick);
+ }
+ sceCtrlReadBufferPositive(&input, 1);
+}
+// fclose(fp);
+
+wait:
+ mp4ff_close(mp4_handle);
+ fclose(mp4_file);
+ pspDebugScreenPrintf("\n");
+ pspDebugScreenPrintf("press triangle to exit...\n");
+ sceCtrlReadBufferPositive(&input, 1);
+ while(!(input.Buttons & PSP_CTRL_TRIANGLE))
+ {
+ sceKernelDelayThread(10000); // wait 10 milliseconds
+ sceCtrlReadBufferPositive(&input, 1);
+ }
+
+ sceKernelExitGame();
+ return 0;
+}
+
+
+/* Exit callback */
+int exit_callback(int arg1, int arg2, void *common)
+{
+ sceKernelExitGame();
+ return 0;
+}
+
+
+/* Callback thread */
+int CallbackThread(SceSize args, void *argp)
+{
+ int cbid;
+
+ cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
+ sceKernelRegisterExitCallback(cbid);
+
+ sceKernelSleepThreadCB();
+
+ return 0;
+}
+
+
+/* Sets up the callback thread and returns its thread id */
+int SetupCallbacks(void)
+{
+ int thid = 0;
+
+ thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
+ if(thid >= 0)
+ {
+ sceKernelStartThread(thid, 0, 0);
+ }
+
+ return thid;
+}

Added: trunk/Tests/avcdecodetest/mem64.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mem64.c Sun Apr 6 05:36:03 2008
@@ -0,0 +1,44 @@
+/*
+PMP Mod
+Copyright (C) 2006 jonny
+
+Homepage: http://jonny.leffe.dnsalias.com
+E-mail: jo...@leffe.dnsalias.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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+64 bytes aligned malloc, with the me is crucial to well enclose data (due to cache)
+*/
+
+
+#include "mem64.h"
+
+
+void *malloc_64(int size)
+ {
+ int mod_64 = size & 0x3f;
+
+ if (mod_64 != 0) size += 64 - mod_64;
+
+ return(memalign(64, size));
+ }
+
+
+void free_64(void *p)
+ {
+ free(p);
+ }

Added: trunk/Tests/avcdecodetest/mem64.h
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mem64.h Sun Apr 6 05:36:03 2008
@@ -0,0 +1,40 @@
+/*
+PMP Mod
+Copyright (C) 2006 jonny
+
+Homepage: http://jonny.leffe.dnsalias.com
+E-mail: jo...@leffe.dnsalias.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., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+64 bytes aligned malloc, with the me is crucial to well enclose data (due to cache)
+*/
+
+
+#ifndef mem64_h
+#define mem64_h
+
+
+#include <stdlib.h>
+#include <malloc.h>
+
+
+void *malloc_64(int size);
+void free_64(void *p);
+
+
+#endif

Added: trunk/Tests/avcdecodetest/mp4ff/Makefile
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/Makefile Sun Apr 6 05:36:03 2008
@@ -0,0 +1,4 @@
+all:
+ make -C src
+clean:
+ make -C src clean

Added: trunk/Tests/avcdecodetest/mp4ff/include/config.h
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/include/config.h Sun Apr 6 05:36:03 2008
@@ -0,0 +1,97 @@
+/* config.h. Generated by configure. */
+/* config.h.in. Generated from configure.in by autoheader. */
+
+/* Define if you want to use libfaad together with Digital Radio Mondiale
+ (DRM) */
+/* #undef DRM */
+
+/* Define if you want support for Digital Radio Mondiale (DRM) parametric
+ stereo */
+/* #undef DRM_PS */
+
+/* User wants beep media player plugin built */
+/* #undef HAVE_BMP */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+/* #undef HAVE_DLFCN_H */
+
+/* Define to 1 if you have the <errno.h> header file. */
+#define HAVE_ERRNO_H 1
+
+/* Define if needed */
+/* #undef HAVE_FLOAT32_T */
+
+/* Define to 1 if you have the <float.h> header file. */
+//#define HAVE_FLOAT_H 1
+
+/* Define to 1 if you have the `getpwuid' function. */
+/* #undef HAVE_GETPWUID */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define if you have the IOKit API */
+/* #undef HAVE_IOKIT_IOKITLIB_H */
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the <mathf.h> header file. */
+/* #undef HAVE_MATHF_H */
+
+/* Define to 1 if you have the `memcpy' function. */
+#define HAVE_MEMCPY 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+//#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strchr' function. */
+#define HAVE_STRCHR 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+//#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the `strsep' function. */
+/* #undef HAVE_STRSEP */
+
+/* Define to 1 if you have the <sysfs/libsysfs.h> header file. */
+/* #undef HAVE_SYSFS_LIBSYSFS_H */
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
+#define TIME_WITH_SYS_TIME 1
+
+
+/* Define to 1 if your processor stores words with the most significant byte
+ first (like Motorola and SPARC, unlike Intel and VAX). */
+/* #undef WORDS_BIGENDIAN */
+
+/* Define as `__inline' if that's what the C compiler calls it, or to nothing
+ if it is not supported. */
+/* #undef inline */
+
+/* Define to `long' if <sys/types.h> does not define. */
+/* #undef off_t */

Added: trunk/Tests/avcdecodetest/mp4ff/include/drms.h
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/include/drms.h Sun Apr 6 05:36:03 2008
@@ -0,0 +1,30 @@
+/*****************************************************************************
+ * drms.h : DRMS
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id: drms.h,v 1.7 2005/02/01 13:15:55 menno Exp $
+ *
+ * Author: Jon Lech Johansen <jon...@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.
+ *****************************************************************************/
+
+extern void *drms_alloc( char *psz_homedir );
+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 );
+

Added: trunk/Tests/avcdecodetest/mp4ff/include/drmstables.h
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/include/drmstables.h Sun Apr 6 05:36:03 2008
@@ -0,0 +1,288 @@
+/*****************************************************************************
+ * drmstables.h : AES/Rijndael block cipher and miscellaneous tables
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id: drmstables.h,v 1.6 2005/02/01 13:15:55 menno Exp $
+ *
+ * Author: Jon Lech Johansen <jon...@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 AES_ROR( x, n ) (((x) << (32-(n))) | ((x) >> (n)))
+
+#define AES_XOR_ROR( p_table, p_tmp ) \
+ ( p_table[ (p_tmp[ t > 2 ? t - 3 : t + 1 ] >> 24) & 0xFF ] \
+ ^ AES_ROR( p_table[ (p_tmp[ t > 1 ? t - 2 : t + 2 ] >> 16) & 0xFF ], 8 ) \
+ ^ AES_ROR( p_table[ (p_tmp[ t > 0 ? t - 1 : t + 3 ] >> 8) & 0xFF ], 16 ) \
+ ^ AES_ROR( p_table[ p_tmp[ t ] & 0xFF ], 24 ) )
+
+#define AES_KEY_COUNT 10
+
+static uint32_t const p_aes_table[ AES_KEY_COUNT ] =
+{
+ 0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020,
+ 0x00000040, 0x00000080, 0x0000001b, 0x00000036
+};
+
+static uint32_t const p_aes_encrypt[ 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 const p_aes_itable[ 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 const p_aes_decrypt[ 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 uint16_t const p_shuffle_xor[ 256 ] =
+{
+ 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 const p_shuffle_sub[ 256 ] =
+{
+ 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 const p_shuffle_add[ 256 ] =
+{
+ 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
+};
+

Added: trunk/Tests/avcdecodetest/mp4ff/include/mp4ff.h
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/include/mp4ff.h Sun Apr 6 05:36:03 2008
@@ -0,0 +1,137 @@
+/*
+** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
+** Copyright (C) 2003-2005 M. Bakker, Nero 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.
+**
+** Software using this code must display the following message visibly in or
+** on each copy of the software:
+** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Nero AG, www.nero.com"
+** in, for example, the about-box or help/startup screen.
+**
+** Commercial non-GPL licensing of this software is possible.
+** For more info contact Nero AG through Mpeg4AA...@nero.com.
+**
+** $Id: mp4ff.h,v 1.24 2006/05/17 18:49:20 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);
+mp4ff_t *mp4ff_open_read_metaonly(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_avc_sps_pps(const mp4ff_t *f, const track, unsigned char** buffer, unsigned int* sps_size, unsigned int* pps_size);
+
+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_totaltracks(const mp4ff_t *f, char **value);
+int mp4ff_meta_get_totaldiscs(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

Added: trunk/Tests/avcdecodetest/mp4ff/include/mp4ff_int_types.h
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/include/mp4ff_int_types.h Sun Apr 6 05:36:03 2008
@@ -0,0 +1,23 @@
+#ifndef _MP4FF_INT_TYPES_H_
+#define _MP4FF_INT_TYPES_H_
+
+#if defined (_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

Added: trunk/Tests/avcdecodetest/mp4ff/include/mp4ffint.h
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/include/mp4ffint.h Sun Apr 6 05:36:03 2008
@@ -0,0 +1,391 @@
+/*
+** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
+** Copyright (C) 2003-2005 M. Bakker, Nero 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.
+**
+** Software using this code must display the following message visibly in or
+** on each copy of the software:
+** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Nero AG, www.nero.com"
+** in, for example, the about-box or help/startup screen.
+**
+** Commercial non-GPL licensing of this software is possible.
+** For more info contact Nero AG through Mpeg4AA...@nero.com.
+**
+** $Id: mp4ffint.h,v 1.20 2006/05/07 18:09:00 menno Exp $
+**/
+
+#ifndef MP4FF_INTERNAL_H
+#define MP4FF_INTERNAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include "mp4ff_int_types.h"
+#include <stdlib.h>
+
+#if defined(_WIN32) && !defined(_WIN32_WCE)
+#define ITUNES_DRM
+
+static __inline uint32_t GetDWLE( void const * _p )
+{
+ uint8_t * p = (uint8_t *)_p;
+ return ( ((uint32_t)p[3] << 24) | ((uint32_t)p[2] << 16)
+ | ((uint32_t)p[1] << 8) | p[0] );
+}
+static __inline uint32_t U32_AT( void const * _p )
+{
+ uint8_t * p = (uint8_t *)_p;
+ return ( ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16)
+ | ((uint32_t)p[2] << 8) | p[3] );
+}
+static __inline uint64_t U64_AT( void const * _p )
+{
+ uint8_t * p = (uint8_t *)_p;
+ return ( ((uint64_t)p[0] << 56) | ((uint64_t)p[1] << 48)
+ | ((uint64_t)p[2] << 40) | ((uint64_t)p[3] << 32)
+ | ((uint64_t)p[4] << 24) | ((uint64_t)p[5] << 16)
+ | ((uint64_t)p[6] << 8) | p[7] );
+}
+
+#ifdef WORDS_BIGENDIAN
+# define VLC_FOURCC( a, b, c, d ) \
+ ( ((uint32_t)d) | ( ((uint32_t)c) << 8 ) \
+ | ( ((uint32_t)b) << 16 ) | ( ((uint32_t)a) << 24 ) )
+# define VLC_TWOCC( a, b ) \
+ ( (uint16_t)(b) | ( (uint16_t)(a) << 8 ) )
+
+#else
+# define VLC_FOURCC( a, b, c, d ) \
+ ( ((uint32_t)a) | ( ((uint32_t)b) << 8 ) \
+ | ( ((uint32_t)c) << 16 ) | ( ((uint32_t)d) << 24 ) )
+# define VLC_TWOCC( a, b ) \
+ ( (uint16_t)(a) | ( (uint16_t)(b) << 8 ) )
+#endif
+
+#define FOURCC_user VLC_FOURCC( 'u', 's', 'e', 'r' )
+#define FOURCC_key VLC_FOURCC( 'k', 'e', 'y', ' ' )
+#define FOURCC_iviv VLC_FOURCC( 'i', 'v', 'i', 'v' )
+#define FOURCC_name VLC_FOURCC( 'n', 'a', 'm', 'e' )
+#define FOURCC_priv VLC_FOURCC( 'p', 'r', 'i', 'v' )
+
+#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_USER 155
+#define ATOM_KEY 156
+
+#define ATOM_AVC1 157
+
+#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
+
+#define ATOM_AVCC 26
+
+#ifdef HAVE_CONFIG_H
+#include "../../config.h"
+#endif
+
+#if !(defined(_WIN32) || defined(_WIN32_WCE))
+#define stricmp strcasecmp
+#else
+#define stricmp _stricmp
+#define strdup _strdup
+#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;
+
+ int32_t width;
+ int32_t height;
+ int32_t avc_sps_size;
+ uint8_t* avc_sps;
+ int32_t avc_pps_size;
+ uint8_t* avc_pps;
+
+#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,int meta_only);
+int32_t parse_atoms(mp4ff_t *f,int meta_only);
+
+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

Added: trunk/Tests/avcdecodetest/mp4ff/src/Makefile
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/src/Makefile Sun Apr 6 05:36:03 2008
@@ -0,0 +1,15 @@
+PSPSDK=$(shell psp-config --pspsdk-path)
+PSPDIR=$(shell psp-config --psp-prefix)
+TARGET_LIB = ../../libmp4ff.a
+OBJS = mp4ff.o mp4atom.o mp4meta.o mp4sample.o mp4util.o \
+ mp4tagupdate.o
+INCDIR = ../include
+CFLAGS = -O2 -G0 -fomit-frame-pointer -fPIC -DUSE_TAGGING=1
+CXXFLAGS = $(CFLAGS) -fno-rtti
+ASFLAGS = $(CFLAGS)
+
+include $(PSPSDK)/lib/build.mak
+
+clean:
+ rm -f *.o
+ rm -f ../../libmp4ff.a
\ No newline at end of file

Added: trunk/Tests/avcdecodetest/mp4ff/src/drms.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/src/drms.c Sun Apr 6 05:36:03 2008
@@ -0,0 +1,1321 @@
+/*****************************************************************************
+ * drms.c: DRMS
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id: drms.c,v 1.7 2005/02/01 13:15:55 menno Exp $
+ *
+ * Authors: Jon Lech Johansen <jon...@nanocrew.net>
+ * Sam Hocevar <s...@zoy.org>
+ *
+ * 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.
+ *****************************************************************************/
+
+#include <stdlib.h> /* malloc(), free() */
+
+#ifndef _WIN32
+#include "config.h"
+#endif
+#include "mp4ffint.h"
+
+#ifdef ITUNES_DRM
+
+#ifdef _WIN32
+# include <io.h>
+# include <stdio.h>
+# include <sys/stat.h>
+# define PATH_MAX MAX_PATH
+#else
+# include <stdio.h>
+#endif
+
+#ifdef HAVE_ERRNO_H
+# include <errno.h>
+#endif
+
+#ifdef _WIN32
+# include <tchar.h>
+# include <shlobj.h>
+# include <windows.h>
+#endif
+
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+/* In Solaris (and perhaps others) PATH_MAX is in limits.h. */
+#ifdef HAVE_LIMITS_H
+# include <limits.h>
+#endif
+
+#ifdef HAVE_IOKIT_IOKITLIB_H
+# include <mach/mach.h>
+# include <IOKit/IOKitLib.h>
+# include <CoreFoundation/CFNumber.h>
+#endif
+
+#ifdef HAVE_SYSFS_LIBSYSFS_H
+# include <sysfs/libsysfs.h>
+#endif
+
+#include "drms.h"
+#include "drmstables.h"
+
+/*****************************************************************************
+ * aes_s: AES keys structure
+ *****************************************************************************
+ * This structure stores a set of keys usable for encryption and decryption
+ * with the AES/Rijndael algorithm.
+ *****************************************************************************/
+struct aes_s
+{
+ uint32_t pp_enc_keys[ AES_KEY_COUNT + 1 ][ 4 ];
+ uint32_t pp_dec_keys[ AES_KEY_COUNT + 1 ][ 4 ];
+};
+
+/*****************************************************************************
+ * md5_s: MD5 message structure
+ *****************************************************************************
+ * This structure stores the static information needed to compute an MD5
+ * hash. It has an extra data buffer to allow non-aligned writes.
+ *****************************************************************************/
+struct md5_s
+{
+ uint64_t i_bits; /* Total written bits */
+ uint32_t p_digest[4]; /* The MD5 digest */
+ uint32_t p_data[16]; /* Buffer to cache non-aligned writes */
+};
+
+/*****************************************************************************
+ * shuffle_s: shuffle structure
+ *****************************************************************************
+ * This structure stores the static information needed to shuffle data using
+ * a custom algorithm.
+ *****************************************************************************/
+struct shuffle_s
+{
+ uint32_t p_commands[ 20 ];
+ uint32_t p_bordel[ 16 ];
+};
+
+/*****************************************************************************
+ * drms_s: DRMS structure
+ *****************************************************************************
+ * This structure stores the static information needed to decrypt DRMS data.
+ *****************************************************************************/
+struct drms_s
+{
+ uint32_t i_user;
+ uint32_t i_key;
+ uint8_t p_iviv[ 16 ];
+ uint8_t *p_name;
+
+ uint32_t p_key[ 4 ];
+ struct aes_s aes;
+
+ char psz_homedir[ PATH_MAX ];
+};
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+static void InitAES ( struct aes_s *, uint32_t * );
+static void DecryptAES ( struct aes_s *, uint32_t *, const uint32_t * );
+
+static void InitMD5 ( struct md5_s * );
+static void AddMD5 ( struct md5_s *, const uint8_t *, uint32_t );
+static void EndMD5 ( struct md5_s * );
+static void Digest ( struct md5_s *, uint32_t * );
+
+static void InitShuffle ( struct shuffle_s *, uint32_t * );
+static void DoShuffle ( struct shuffle_s *, uint32_t *, uint32_t );
+
+static int GetSystemKey ( uint32_t *, uint32_t );
+static int WriteUserKey ( void *, uint32_t * );
+static int ReadUserKey ( void *, uint32_t * );
+static int GetUserKey ( void *, uint32_t * );
+
+static int GetSCIData ( char *, uint32_t **, uint32_t * );
+static int HashSystemInfo ( uint32_t * );
+static int GetiPodID ( int64_t * );
+
+#ifdef WORDS_BIGENDIAN
+/*****************************************************************************
+ * Reverse: reverse byte order
+ *****************************************************************************/
+static __inline void Reverse( uint32_t *p_buffer, int n )
+{
+ int i;
+
+ for( i = 0; i < n; i++ )
+ {
+ p_buffer[ i ] = GetDWLE(&p_buffer[ i ]);
+ }
+}
+# define REVERSE( p, n ) Reverse( p, n )
+#else
+# define REVERSE( p, n )
+#endif
+
+/*****************************************************************************
+ * BlockXOR: XOR two 128 bit blocks
+ *****************************************************************************/
+static __inline void BlockXOR( uint32_t *p_dest, uint32_t *p_s1, uint32_t *p_s2 )
+{
+ int i;
+
+ for( i = 0; i < 4; i++ )
+ {
+ p_dest[ i ] = p_s1[ i ] ^ p_s2[ i ];
+ }
+}
+
+/*****************************************************************************
+ * drms_alloc: allocate a DRMS structure
+ *****************************************************************************/
+void *drms_alloc( char *psz_homedir )
+{
+ struct drms_s *p_drms;
+
+ p_drms = malloc( sizeof(struct drms_s) );
+
+ if( p_drms == NULL )
+ {
+ return NULL;
+ }
+
+ memset( p_drms, 0, sizeof(struct drms_s) );
+
+ strncpy( p_drms->psz_homedir, psz_homedir, PATH_MAX );
+ p_drms->psz_homedir[ PATH_MAX - 1 ] = '\0';
+
+ return (void *)p_drms;
+}
+
+/*****************************************************************************
+ * drms_free: free a previously allocated DRMS structure
+ *****************************************************************************/
+void drms_free( void *_p_drms )
+{
+ struct drms_s *p_drms = (struct drms_s *)_p_drms;
+
+ if( p_drms->p_name != NULL )
+ {
+ free( (void *)p_drms->p_name );
+ }
+
+ free( p_drms );
+}
+
+/*****************************************************************************
+ * drms_decrypt: unscramble a chunk of data
+ *****************************************************************************/
+void drms_decrypt( void *_p_drms, uint32_t *p_buffer, uint32_t i_bytes )
+{
+ struct drms_s *p_drms = (struct drms_s *)_p_drms;
+ uint32_t p_key[ 4 ];
+ unsigned int i_blocks;
+
+ /* AES is a block cypher, round down the byte count */
+ i_blocks = i_bytes / 16;
+ i_bytes = i_blocks * 16;
+
+ /* Initialise the key */
+ memcpy( p_key, p_drms->p_key, 16 );
+
+ /* Unscramble */
+ while( i_blocks-- )
+ {
+ uint32_t p_tmp[ 4 ];
+
+ REVERSE( p_buffer, 4 );
+ DecryptAES( &p_drms->aes, p_tmp, p_buffer );
+ BlockXOR( p_tmp, p_key, p_tmp );
+
+ /* Use the previous scrambled data as the key for next block */
+ memcpy( p_key, p_buffer, 16 );
+
+ /* Copy unscrambled data back to the buffer */
+ memcpy( p_buffer, p_tmp, 16 );
+ REVERSE( p_buffer, 4 );
+
+ p_buffer += 4;
+ }
+}
+
+/*****************************************************************************
+ * drms_init: initialise a DRMS structure
+ *****************************************************************************/
+int drms_init( void *_p_drms, uint32_t i_type,
+ uint8_t *p_info, uint32_t i_len )
+{
+ struct drms_s *p_drms = (struct drms_s *)_p_drms;
+ int i_ret = 0;
+
+ switch( i_type )
+ {
+ case FOURCC_user:
+ if( i_len < sizeof(p_drms->i_user) )
+ {
+ i_ret = -1;
+ break;
+ }
+
+ p_drms->i_user = U32_AT( p_info );
+ break;
+
+ case FOURCC_key:
+ if( i_len < sizeof(p_drms->i_key) )
+ {
+ i_ret = -1;
+ break;
+ }
+
+ p_drms->i_key = U32_AT( p_info );
+ break;
+
+ case FOURCC_iviv:
+ if( i_len < sizeof(p_drms->p_key) )
+ {
+ i_ret = -1;
+ break;
+ }
+
+ memcpy( p_drms->p_iviv, p_info, 16 );
+ break;
+
+ case FOURCC_name:
+ p_drms->p_name = strdup( p_info );
+
+ if( p_drms->p_name == NULL )
+ {
+ i_ret = -1;
+ }
+ break;
+
+ case FOURCC_priv:
+ {
+ uint32_t p_priv[ 64 ];
+ struct md5_s md5;
+
+ if( i_len < 64 )
+ {
+ i_ret = -1;
+ break;
+ }
+
+ InitMD5( &md5 );
+ AddMD5( &md5, p_drms->p_name, strlen( p_drms->p_name ) );
+ AddMD5( &md5, p_drms->p_iviv, 16 );
+ EndMD5( &md5 );
+
+ if( GetUserKey( p_drms, p_drms->p_key ) )
+ {
+ i_ret = -1;
+ break;
+ }
+
+ InitAES( &p_drms->aes, p_drms->p_key );
+
+ memcpy( p_priv, p_info, 64 );
+ memcpy( p_drms->p_key, md5.p_digest, 16 );
+ drms_decrypt( p_drms, p_priv, 64 );
+ REVERSE( p_priv, 64 );
+
+ if( p_priv[ 0 ] != 0x6e757469 ) /* itun */
+ {
+ i_ret = -1;
+ break;
+ }
+
+ InitAES( &p_drms->aes, p_priv + 6 );
+ memcpy( p_drms->p_key, p_priv + 12, 16 );
+
+ free( (void *)p_drms->p_name );
+ p_drms->p_name = NULL;
+ }
+ break;
+ }
+
+ return i_ret;
+}
+
+/* The following functions are local */
+
+/*****************************************************************************
+ * InitAES: initialise AES/Rijndael encryption/decryption tables
+ *****************************************************************************
+ * The Advanced Encryption Standard (AES) is described in RFC 3268
+ *****************************************************************************/
+static void InitAES( struct aes_s *p_aes, uint32_t *p_key )
+{
+ unsigned int i, t;
+ uint32_t i_key, i_seed;
+
+ memset( p_aes->pp_enc_keys[1], 0, 16 );
+ memcpy( p_aes->pp_enc_keys[0], p_key, 16 );
+
+ /* Generate the key tables */
+ i_seed = p_aes->pp_enc_keys[ 0 ][ 3 ];
+
+ for( i_key = 0; i_key < AES_KEY_COUNT; i_key++ )
+ {
+ uint32_t j;
+
+ i_seed = AES_ROR( i_seed, 8 );
+
+ j = p_aes_table[ i_key ];
+
+ j ^= p_aes_encrypt[ (i_seed >> 24) & 0xff ]
+ ^ AES_ROR( p_aes_encrypt[ (i_seed >> 16) & 0xff ], 8 )
+ ^ AES_ROR( p_aes_encrypt[ (i_seed >> 8) & 0xff ], 16 )
+ ^ AES_ROR( p_aes_encrypt[ i_seed & 0xff ], 24 );
+
+ j ^= p_aes->pp_enc_keys[ i_key ][ 0 ];
+ p_aes->pp_enc_keys[ i_key + 1 ][ 0 ] = j;
+ j ^= p_aes->pp_enc_keys[ i_key ][ 1 ];
+ p_aes->pp_enc_keys[ i_key + 1 ][ 1 ] = j;
+ j ^= p_aes->pp_enc_keys[ i_key ][ 2 ];
+ p_aes->pp_enc_keys[ i_key + 1 ][ 2 ] = j;
+ j ^= p_aes->pp_enc_keys[ i_key ][ 3 ];
+ p_aes->pp_enc_keys[ i_key + 1 ][ 3 ] = j;
+
+ i_seed = j;
+ }
+
+ memcpy( p_aes->pp_dec_keys[ 0 ],
+ p_aes->pp_enc_keys[ 0 ], 16 );
+
+ for( i = 1; i < AES_KEY_COUNT; i++ )
+ {
+ for( t = 0; t < 4; t++ )
+ {
+ uint32_t j, k, l, m, n;
+
+ j = p_aes->pp_enc_keys[ i ][ t ];
+
+ k = (((j >> 7) & 0x01010101) * 27) ^ ((j & 0xff7f7f7f) << 1);
+ l = (((k >> 7) & 0x01010101) * 27) ^ ((k & 0xff7f7f7f) << 1);
+ m = (((l >> 7) & 0x01010101) * 27) ^ ((l & 0xff7f7f7f) << 1);
+
+ j ^= m;
+
+ n = AES_ROR( l ^ j, 16 ) ^ AES_ROR( k ^ j, 8 ) ^ AES_ROR( j, 24 );
+
+ p_aes->pp_dec_keys[ i ][ t ] = k ^ l ^ m ^ n;
+ }
+ }
+}
+
+/*****************************************************************************
+ * DecryptAES: decrypt an AES/Rijndael 128 bit block
+ *****************************************************************************/
+static void DecryptAES( struct aes_s *p_aes,
+ uint32_t *p_dest, const uint32_t *p_src )
+{
+ uint32_t p_wtxt[ 4 ]; /* Working cyphertext */
+ uint32_t p_tmp[ 4 ];
+ unsigned int i_round, t;
+
+ for( t = 0; t < 4; t++ )
+ {
+ /* FIXME: are there any endianness issues here? */
+ p_wtxt[ t ] = p_src[ t ] ^ p_aes->pp_enc_keys[ AES_KEY_COUNT ][ t ];
+ }
+
+ /* Rounds 0 - 8 */
+ for( i_round = 0; i_round < (AES_KEY_COUNT - 1); i_round++ )
+ {
+ for( t = 0; t < 4; t++ )
+ {
+ p_tmp[ t ] = AES_XOR_ROR( p_aes_itable, p_wtxt );
+ }
+
+ for( t = 0; t < 4; t++ )
+ {
+ p_wtxt[ t ] = p_tmp[ t ]
+ ^ p_aes->pp_dec_keys[ (AES_KEY_COUNT - 1) - i_round ][ t ];
+ }
+ }
+
+ /* Final round (9) */
+ for( t = 0; t < 4; t++ )
+ {
+ p_dest[ t ] = AES_XOR_ROR( p_aes_decrypt, p_wtxt );
+ p_dest[ t ] ^= p_aes->pp_dec_keys[ 0 ][ t ];
+ }
+}
+
+/*****************************************************************************
+ * InitMD5: initialise an MD5 message
+ *****************************************************************************
+ * The MD5 message-digest algorithm is described in RFC 1321
+ *****************************************************************************/
+static void InitMD5( struct md5_s *p_md5 )
+{
+ p_md5->p_digest[ 0 ] = 0x67452301;
+ p_md5->p_digest[ 1 ] = 0xefcdab89;
+ p_md5->p_digest[ 2 ] = 0x98badcfe;
+ p_md5->p_digest[ 3 ] = 0x10325476;
+
+ memset( p_md5->p_data, 0, 64 );
+ p_md5->i_bits = 0;
+}
+
+/*****************************************************************************
+ * AddMD5: add i_len bytes to an MD5 message
+ *****************************************************************************/
+static void AddMD5( struct md5_s *p_md5, const uint8_t *p_src, uint32_t i_len )
+{
+ unsigned int i_current; /* Current bytes in the spare buffer */
+ unsigned int i_offset = 0;
+
+ i_current = (p_md5->i_bits / 8) & 63;
+
+ p_md5->i_bits += 8 * i_len;
+
+ /* If we can complete our spare buffer to 64 bytes, do it and add the
+ * resulting buffer to the MD5 message */
+ if( i_len >= (64 - i_current) )
+ {
+ memcpy( ((uint8_t *)p_md5->p_data) + i_current, p_src,
+ (64 - i_current) );
+ Digest( p_md5, p_md5->p_data );
+
+ i_offset += (64 - i_current);
+ i_len -= (64 - i_current);
+ i_current = 0;
+ }
+
+ /* Add as many entire 64 bytes blocks as we can to the MD5 message */
+ while( i_len >= 64 )
+ {
+ uint32_t p_tmp[ 16 ];
+ memcpy( p_tmp, p_src + i_offset, 64 );
+ Digest( p_md5, p_tmp );
+ i_offset += 64;
+ i_len -= 64;
+ }
+
+ /* Copy our remaining data to the message's spare buffer */
+ memcpy( ((uint8_t *)p_md5->p_data) + i_current, p_src + i_offset, i_len );
+}
+
+/*****************************************************************************
+ * EndMD5: finish an MD5 message
+ *****************************************************************************
+ * This function adds adequate padding to the end of the message, and appends
+ * the bit count so that we end at a block boundary.
+ *****************************************************************************/
+static void EndMD5( struct md5_s *p_md5 )
+{
+ unsigned int i_current;
+
+ i_current = (p_md5->i_bits / 8) & 63;
+
+ /* Append 0x80 to our buffer. No boundary check because the temporary
+ * buffer cannot be full, otherwise AddMD5 would have emptied it. */
+ ((uint8_t *)p_md5->p_data)[ i_current++ ] = 0x80;
+
+ /* If less than 8 bytes are available at the end of the block, complete
+ * this 64 bytes block with zeros and add it to the message. We'll add
+ * our length at the end of the next block. */
+ if( i_current > 56 )
+ {
+ memset( ((uint8_t *)p_md5->p_data) + i_current, 0, (64 - i_current) );
+ Digest( p_md5, p_md5->p_data );
+ i_current = 0;
+ }
+
+ /* Fill the unused space in our last block with zeroes and put the
+ * message length at the end. */
+ memset( ((uint8_t *)p_md5->p_data) + i_current, 0, (56 - i_current) );
+ p_md5->p_data[ 14 ] = p_md5->i_bits & 0xffffffff;
+ p_md5->p_data[ 15 ] = (p_md5->i_bits >> 32);
+ REVERSE( &p_md5->p_data[ 14 ], 2 );
+
+ Digest( p_md5, p_md5->p_data );
+}
+
+#define F1( x, y, z ) ((z) ^ ((x) & ((y) ^ (z))))
+#define F2( x, y, z ) F1((z), (x), (y))
+#define F3( x, y, z ) ((x) ^ (y) ^ (z))
+#define F4( x, y, z ) ((y) ^ ((x) | ~(z)))
+
+#define MD5_DO( f, w, x, y, z, data, s ) \
+ ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
+
+/*****************************************************************************
+ * Digest: update the MD5 digest with 64 bytes of data
+ *****************************************************************************/
+static void Digest( struct md5_s *p_md5, uint32_t *p_input )
+{
+ uint32_t a, b, c, d;
+
+ REVERSE( p_input, 16 );
+
+ a = p_md5->p_digest[ 0 ];
+ b = p_md5->p_digest[ 1 ];
+ c = p_md5->p_digest[ 2 ];
+ d = p_md5->p_digest[ 3 ];
+
+ MD5_DO( F1, a, b, c, d, p_input[ 0 ] + 0xd76aa478, 7 );
+ MD5_DO( F1, d, a, b, c, p_input[ 1 ] + 0xe8c7b756, 12 );
+ MD5_DO( F1, c, d, a, b, p_input[ 2 ] + 0x242070db, 17 );
+ MD5_DO( F1, b, c, d, a, p_input[ 3 ] + 0xc1bdceee, 22 );
+ MD5_DO( F1, a, b, c, d, p_input[ 4 ] + 0xf57c0faf, 7 );
+ MD5_DO( F1, d, a, b, c, p_input[ 5 ] + 0x4787c62a, 12 );
+ MD5_DO( F1, c, d, a, b, p_input[ 6 ] + 0xa8304613, 17 );
+ MD5_DO( F1, b, c, d, a, p_input[ 7 ] + 0xfd469501, 22 );
+ MD5_DO( F1, a, b, c, d, p_input[ 8 ] + 0x698098d8, 7 );
+ MD5_DO( F1, d, a, b, c, p_input[ 9 ] + 0x8b44f7af, 12 );
+ MD5_DO( F1, c, d, a, b, p_input[ 10 ] + 0xffff5bb1, 17 );
+ MD5_DO( F1, b, c, d, a, p_input[ 11 ] + 0x895cd7be, 22 );
+ MD5_DO( F1, a, b, c, d, p_input[ 12 ] + 0x6b901122, 7 );
+ MD5_DO( F1, d, a, b, c, p_input[ 13 ] + 0xfd987193, 12 );
+ MD5_DO( F1, c, d, a, b, p_input[ 14 ] + 0xa679438e, 17 );
+ MD5_DO( F1, b, c, d, a, p_input[ 15 ] + 0x49b40821, 22 );
+
+ MD5_DO( F2, a, b, c, d, p_input[ 1 ] + 0xf61e2562, 5 );
+ MD5_DO( F2, d, a, b, c, p_input[ 6 ] + 0xc040b340, 9 );
+ MD5_DO( F2, c, d, a, b, p_input[ 11 ] + 0x265e5a51, 14 );
+ MD5_DO( F2, b, c, d, a, p_input[ 0 ] + 0xe9b6c7aa, 20 );
+ MD5_DO( F2, a, b, c, d, p_input[ 5 ] + 0xd62f105d, 5 );
+ MD5_DO( F2, d, a, b, c, p_input[ 10 ] + 0x02441453, 9 );
+ MD5_DO( F2, c, d, a, b, p_input[ 15 ] + 0xd8a1e681, 14 );
+ MD5_DO( F2, b, c, d, a, p_input[ 4 ] + 0xe7d3fbc8, 20 );
+ MD5_DO( F2, a, b, c, d, p_input[ 9 ] + 0x21e1cde6, 5 );
+ MD5_DO( F2, d, a, b, c, p_input[ 14 ] + 0xc33707d6, 9 );
+ MD5_DO( F2, c, d, a, b, p_input[ 3 ] + 0xf4d50d87, 14 );
+ MD5_DO( F2, b, c, d, a, p_input[ 8 ] + 0x455a14ed, 20 );
+ MD5_DO( F2, a, b, c, d, p_input[ 13 ] + 0xa9e3e905, 5 );
+ MD5_DO( F2, d, a, b, c, p_input[ 2 ] + 0xfcefa3f8, 9 );
+ MD5_DO( F2, c, d, a, b, p_input[ 7 ] + 0x676f02d9, 14 );
+ MD5_DO( F2, b, c, d, a, p_input[ 12 ] + 0x8d2a4c8a, 20 );
+
+ MD5_DO( F3, a, b, c, d, p_input[ 5 ] + 0xfffa3942, 4 );
+ MD5_DO( F3, d, a, b, c, p_input[ 8 ] + 0x8771f681, 11 );
+ MD5_DO( F3, c, d, a, b, p_input[ 11 ] + 0x6d9d6122, 16 );
+ MD5_DO( F3, b, c, d, a, p_input[ 14 ] + 0xfde5380c, 23 );
+ MD5_DO( F3, a, b, c, d, p_input[ 1 ] + 0xa4beea44, 4 );
+ MD5_DO( F3, d, a, b, c, p_input[ 4 ] + 0x4bdecfa9, 11 );
+ MD5_DO( F3, c, d, a, b, p_input[ 7 ] + 0xf6bb4b60, 16 );
+ MD5_DO( F3, b, c, d, a, p_input[ 10 ] + 0xbebfbc70, 23 );
+ MD5_DO( F3, a, b, c, d, p_input[ 13 ] + 0x289b7ec6, 4 );
+ MD5_DO( F3, d, a, b, c, p_input[ 0 ] + 0xeaa127fa, 11 );
+ MD5_DO( F3, c, d, a, b, p_input[ 3 ] + 0xd4ef3085, 16 );
+ MD5_DO( F3, b, c, d, a, p_input[ 6 ] + 0x04881d05, 23 );
+ MD5_DO( F3, a, b, c, d, p_input[ 9 ] + 0xd9d4d039, 4 );
+ MD5_DO( F3, d, a, b, c, p_input[ 12 ] + 0xe6db99e5, 11 );
+ MD5_DO( F3, c, d, a, b, p_input[ 15 ] + 0x1fa27cf8, 16 );
+ MD5_DO( F3, b, c, d, a, p_input[ 2 ] + 0xc4ac5665, 23 );
+
+ MD5_DO( F4, a, b, c, d, p_input[ 0 ] + 0xf4292244, 6 );
+ MD5_DO( F4, d, a, b, c, p_input[ 7 ] + 0x432aff97, 10 );
+ MD5_DO( F4, c, d, a, b, p_input[ 14 ] + 0xab9423a7, 15 );
+ MD5_DO( F4, b, c, d, a, p_input[ 5 ] + 0xfc93a039, 21 );
+ MD5_DO( F4, a, b, c, d, p_input[ 12 ] + 0x655b59c3, 6 );
+ MD5_DO( F4, d, a, b, c, p_input[ 3 ] + 0x8f0ccc92, 10 );
+ MD5_DO( F4, c, d, a, b, p_input[ 10 ] + 0xffeff47d, 15 );
+ MD5_DO( F4, b, c, d, a, p_input[ 1 ] + 0x85845dd1, 21 );
+ MD5_DO( F4, a, b, c, d, p_input[ 8 ] + 0x6fa87e4f, 6 );
+ MD5_DO( F4, d, a, b, c, p_input[ 15 ] + 0xfe2ce6e0, 10 );
+ MD5_DO( F4, c, d, a, b, p_input[ 6 ] + 0xa3014314, 15 );
+ MD5_DO( F4, b, c, d, a, p_input[ 13 ] + 0x4e0811a1, 21 );
+ MD5_DO( F4, a, b, c, d, p_input[ 4 ] + 0xf7537e82, 6 );
+ MD5_DO( F4, d, a, b, c, p_input[ 11 ] + 0xbd3af235, 10 );
+ MD5_DO( F4, c, d, a, b, p_input[ 2 ] + 0x2ad7d2bb, 15 );
+ MD5_DO( F4, b, c, d, a, p_input[ 9 ] + 0xeb86d391, 21 );
+
+ p_md5->p_digest[ 0 ] += a;
+ p_md5->p_digest[ 1 ] += b;
+ p_md5->p_digest[ 2 ] += c;
+ p_md5->p_digest[ 3 ] += d;
+}
+
+/*****************************************************************************
+ * InitShuffle: initialise a shuffle structure
+ *****************************************************************************
+ * This function initialises tables in the p_shuffle structure that will be
+ * used later by DoShuffle. The only external parameter is p_sys_key.
+ *****************************************************************************/
+static void InitShuffle( struct shuffle_s *p_shuffle, uint32_t *p_sys_key )
+{
+ char p_secret1[] = "Tv!*";
+ static char const p_secret2[] = "v8rhvsaAvOKMFfUH%798=[;."
+ "f8677680a634ba87fnOIf)(*";
+ unsigned int i;
+
+ /* Fill p_commands using the key and a secret seed */
+ for( i = 0; i < 20; i++ )
+ {
+ struct md5_s md5;
+ int32_t i_hash;
+
+ InitMD5( &md5 );
+ AddMD5( &md5, (uint8_t *)p_sys_key, 16 );
+ AddMD5( &md5, (uint8_t *)p_secret1, 4 );
+ EndMD5( &md5 );
+
+ p_secret1[ 3 ]++;
+
+ REVERSE( md5.p_digest, 1 );
+ i_hash = ((int32_t)U32_AT(md5.p_digest)) % 1024;
+
+ p_shuffle->p_commands[ i ] = i_hash < 0 ? i_hash * -1 : i_hash;
+ }
+
+ /* Fill p_bordel with completely meaningless initial values. */
+ for( i = 0; i < 4; i++ )
+ {
+ p_shuffle->p_bordel[ 4 * i ] = U32_AT(p_sys_key + i);
+ memcpy( p_shuffle->p_bordel + 4 * i + 1, p_secret2 + 12 * i, 12 );
+ REVERSE( p_shuffle->p_bordel + 4 * i + 1, 3 );
+ }
+}
+
+/*****************************************************************************
+ * DoShuffle: shuffle buffer
+ *****************************************************************************
+ * This is so ugly and uses so many MD5 checksums that it is most certainly
+ * one-way, though why it needs to be so complicated is beyond me.
+ *****************************************************************************/
+static void DoShuffle( struct shuffle_s *p_shuffle,
+ uint32_t *p_buffer, uint32_t i_size )
+{
+ struct md5_s md5;
+ uint32_t p_big_bordel[ 16 ];
+ uint32_t *p_bordel = p_shuffle->p_bordel;
+ unsigned int i;
+
+ /* Using the MD5 hash of a memory block is probably not one-way enough
+ * for the iTunes people. This function randomises p_bordel depending on
+ * the values in p_commands to make things even more messy in p_bordel. */
+ for( i = 0; i < 20; i++ )
+ {
+ uint8_t i_command, i_index;
+
+ if( !p_shuffle->p_commands[ i ] )
+ {
+ continue;
+ }
+
+ i_command = (p_shuffle->p_commands[ i ] & 0x300) >> 8;
+ i_index = p_shuffle->p_commands[ i ] & 0xff;
+
+ switch( i_command )
+ {
+ case 0x3:
+ p_bordel[ i_index & 0xf ] = p_bordel[ i_index >> 4 ]
+ + p_bordel[ ((i_index + 0x10) >> 4) & 0xf ];
+ break;
+ case 0x2:
+ p_bordel[ i_index >> 4 ] ^= p_shuffle_xor[ 0xff - i_index ];
+ break;
+ case 0x1:
+ p_bordel[ i_index >> 4 ] -= p_shuffle_sub[ 0xff - i_index ];
+ break;
+ default:
+ p_bordel[ i_index >> 4 ] += p_shuffle_add[ 0xff - i_index ];
+ break;
+ }
+ }
+
+ /* Convert our newly randomised p_bordel to big endianness and take
+ * its MD5 hash. */
+ InitMD5( &md5 );
+ for( i = 0; i < 16; i++ )
+ {
+ p_big_bordel[ i ] = U32_AT(p_bordel + i);
+ }
+ AddMD5( &md5, (uint8_t *)p_big_bordel, 64 );
+ EndMD5( &md5 );
+
+ /* XOR our buffer with the computed checksum */
+ for( i = 0; i < i_size; i++ )
+ {
+ p_buffer[ i ] ^= md5.p_digest[ i ];
+ }
+}
+
+/*****************************************************************************
+ * GetSystemKey: get the system key
+ *****************************************************************************
+ * Compute the system key from various system information, see HashSystemInfo.
+ *****************************************************************************/
+static int GetSystemKey( uint32_t *p_sys_key, uint32_t b_ipod )
+{
+ static char const p_secret1[ 8 ] = "YuaFlafu";
+ static char const p_secret2[ 8 ] = "zPif98ga";
+ struct md5_s md5;
+ int64_t i_ipod_id;
+ uint32_t p_system_hash[ 4 ];
+
+ /* Compute the MD5 hash of our system info */
+ if( ( !b_ipod && HashSystemInfo( p_system_hash ) ) ||
+ ( b_ipod && GetiPodID( &i_ipod_id ) ) )
+ {
+ return -1;
+ }
+
+ /* Combine our system info hash with additional secret data. The resulting
+ * MD5 hash will be our system key. */
+ InitMD5( &md5 );
+ AddMD5( &md5, p_secret1, 8 );
+
+ if( !b_ipod )
+ {
+ AddMD5( &md5, (uint8_t *)p_system_hash, 6 );
+ AddMD5( &md5, (uint8_t *)p_system_hash, 6 );
+ AddMD5( &md5, (uint8_t *)p_system_hash, 6 );
+ AddMD5( &md5, p_secret2, 8 );
+ }
+ else
+ {
+ i_ipod_id = U64_AT(&i_ipod_id);
+ AddMD5( &md5, (uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );
+ AddMD5( &md5, (uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );
+ AddMD5( &md5, (uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );
+ }
+
+ EndMD5( &md5 );
+
+ memcpy( p_sys_key, md5.p_digest, 16 );
+
+ return 0;
+}
+
+#ifdef _WIN32
+# define DRMS_DIRNAME "drms"
+#else
+# define DRMS_DIRNAME ".drms"
+#endif
+
+/*****************************************************************************
+ * WriteUserKey: write the user key to hard disk
+ *****************************************************************************
+ * Write the user key to the hard disk so that it can be reused later or used
+ * on operating systems other than Win32.
+ *****************************************************************************/
+static int WriteUserKey( void *_p_drms, uint32_t *p_user_key )
+{
+ struct drms_s *p_drms = (struct drms_s *)_p_drms;
+ FILE *file;
+ int i_ret = -1;
+ char psz_path[ PATH_MAX ];
+
+ sprintf( psz_path, /* PATH_MAX - 1, */
+ "%s/" DRMS_DIRNAME, p_drms->psz_homedir );
+
+#if defined( HAVE_ERRNO_H )
+# if defined( _WIN32 )
+ if( !mkdir( psz_path ) || errno == EEXIST )
+# else
+ if( !mkdir( psz_path, 0755 ) || errno == EEXIST )
+# endif
+#else
+ if( !mkdir( psz_path ) )
+#endif
+ {
+ sprintf( psz_path, /*PATH_MAX - 1,*/ "%s/" DRMS_DIRNAME "/%08X.%03d",
+ p_drms->psz_homedir, p_drms->i_user, p_drms->i_key );
+
+ file = fopen( psz_path, "w" );
+ if( file != NULL )
+ {
+ i_ret = fwrite( p_user_key, sizeof(uint32_t),
+ 4, file ) == 4 ? 0 : -1;
+ fclose( file );
+ }
+ }
+
+ return i_ret;
+}
+
+/*****************************************************************************
+ * ReadUserKey: read the user key from hard disk
+ *****************************************************************************
+ * Retrieve the user key from the hard disk if available.
+ *****************************************************************************/
+static int ReadUserKey( void *_p_drms, uint32_t *p_user_key )
+{
+ struct drms_s *p_drms = (struct drms_s *)_p_drms;
+ FILE *file;
+ int i_ret = -1;
+ char psz_path[ PATH_MAX ];
+
+ sprintf( psz_path, /*PATH_MAX - 1,*/
+ "%s/" DRMS_DIRNAME "/%08X.%03d", p_drms->psz_homedir,
+ p_drms->i_user, p_drms->i_key );
+
+ file = fopen( psz_path, "r" );
+ if( file != NULL )
+ {
+ i_ret = fread( p_user_key, sizeof(uint32_t),
+ 4, file ) == 4 ? 0 : -1;
+ fclose( file );
+ }
+
+ return i_ret;
+}
+
+/*****************************************************************************
+ * GetUserKey: get the user key
+ *****************************************************************************
+ * Retrieve the user key from the hard disk if available, otherwise generate
+ * it from the system key. If the key could be successfully generated, write
+ * it to the hard disk for future use.
+ *****************************************************************************/
+static int GetUserKey( void *_p_drms, uint32_t *p_user_key )
+{
+ static char const p_secret[] = "mUfnpognadfgf873";
+ struct drms_s *p_drms = (struct drms_s *)_p_drms;
+ struct aes_s aes;
+ struct shuffle_s shuffle;
+ uint32_t i, y;
+ uint32_t *p_sci_data;
+ uint32_t i_user, i_key;
+ uint32_t p_sys_key[ 4 ];
+ uint32_t i_sci_size, i_blocks, i_remaining;
+ uint32_t *p_sci0, *p_sci1, *p_buffer;
+ uint32_t p_sci_key[ 4 ];
+ char *psz_ipod;
+ int i_ret = -1;
+
+ if( !ReadUserKey( p_drms, p_user_key ) )
+ {
+ REVERSE( p_user_key, 4 );
+ return 0;
+ }
+
+ psz_ipod = getenv( "IPOD" );
+
+ if( GetSystemKey( p_sys_key, psz_ipod ? 1 : 0 ) )
+ {
+ return -1;
+ }
+
+ if( GetSCIData( psz_ipod, &p_sci_data, &i_sci_size ) )
+ {
+ return -1;
+ }
+
+ /* Phase 1: unscramble the SCI data using the system key and shuffle
+ * it using DoShuffle(). */
+
+ /* Skip the first 4 bytes (some sort of header). Decrypt the rest. */
+ i_blocks = (i_sci_size - 4) / 16;
+ i_remaining = (i_sci_size - 4) - (i_blocks * 16);
+ p_buffer = p_sci_data + 1;
+
+ /* Decrypt and shuffle our data at the same time */
+ InitAES( &aes, p_sys_key );
+ REVERSE( p_sys_key, 4 );
+ InitShuffle( &shuffle, p_sys_key );
+
+ memcpy( p_sci_key, p_secret, 16 );
+ REVERSE( p_sci_key, 4 );
+
+ while( i_blocks-- )
+ {
+ uint32_t p_tmp[ 4 ];
+
+ REVERSE( p_buffer, 4 );
+ DecryptAES( &aes, p_tmp, p_buffer );
+ BlockXOR( p_tmp, p_sci_key, p_tmp );
+
+ /* Use the previous scrambled data as the key for next block */
+ memcpy( p_sci_key, p_buffer, 16 );
+
+ /* Shuffle the decrypted data using a custom routine */
+ DoShuffle( &shuffle, p_tmp, 4 );
+
+ /* Copy this block back to p_buffer */
+ memcpy( p_buffer, p_tmp, 16 );
+
+ p_buffer += 4;
+ }
+
+ if( i_remaining >= 4 )
+ {
+ i_remaining /= 4;
+ REVERSE( p_buffer, i_remaining );
+ DoShuffle( &shuffle, p_buffer, i_remaining );
+ }
+
+ /* Phase 2: look for the user key in the generated data. I must admit I
+ * do not understand what is going on here, because it almost
+ * looks like we are browsing data that makes sense, even though
+ * the DoShuffle() part made it completely meaningless. */
+
+ y = 0;
+ REVERSE( p_sci_data + 5, 1 );
+ i = U32_AT( p_sci_data + 5 );
+ i_sci_size -= 22 * sizeof(uint32_t);
+ p_sci1 = p_sci_data + 22;
+ p_sci0 = NULL;
+
+ while( i_sci_size >= 20 && i > 0 )
+ {
+ if( p_sci0 == NULL )
+ {
+ i_sci_size -= 18 * sizeof(uint32_t);
+ if( i_sci_size < 20 )
+ {
+ break;
+ }
+
+ p_sci0 = p_sci1;
+ REVERSE( p_sci1 + 17, 1 );
+ y = U32_AT( p_sci1 + 17 );
+ p_sci1 += 18;
+ }
+
+ if( !y )
+ {
+ i--;
+ p_sci0 = NULL;
+ continue;
+ }
+
+ i_user = U32_AT( p_sci0 );
+ i_key = U32_AT( p_sci1 );
+ REVERSE( &i_user, 1 );
+ REVERSE( &i_key, 1 );
+ if( i_user == p_drms->i_user && ( ( i_key == p_drms->i_key ) ||
+ ( !p_drms->i_key && ( p_sci1 == (p_sci0 + 18) ) ) ) )
+ {
+ memcpy( p_user_key, p_sci1 + 1, 16 );
+ REVERSE( p_sci1 + 1, 4 );
+ WriteUserKey( p_drms, p_sci1 + 1 );
+ i_ret = 0;
+ break;
+ }
+
+ y--;
+ p_sci1 += 5;
+ i_sci_size -= 5 * sizeof(uint32_t);
+ }
+
+ free( p_sci_data );
+
+ return i_ret;
+}
+
+/*****************************************************************************
+ * GetSCIData: get SCI data from "SC Info.sidb"
+ *****************************************************************************
+ * Read SCI data from "\Apple Computer\iTunes\SC Info\SC Info.sidb"
+ *****************************************************************************/
+static int GetSCIData( char *psz_ipod, uint32_t **pp_sci,
+ uint32_t *pi_sci_size )
+{
+ FILE *file;
+ char *psz_path = NULL;
+ char p_tmp[ PATH_MAX ];
+ int i_ret = -1;
+
+ if( psz_ipod == NULL )
+ {
+#ifdef _WIN32
+ char *p_filename = "\\Apple Computer\\iTunes\\SC Info\\SC Info.sidb";
+ typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,
+ LPSTR );
+ HINSTANCE shfolder_dll = NULL;
+ SHGETFOLDERPATH dSHGetFolderPath = NULL;
+
+ if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )
+ {
+ dSHGetFolderPath =
+ (SHGETFOLDERPATH)GetProcAddress( shfolder_dll,
+ _T("SHGetFolderPathA") );
+ }
+
+ if( dSHGetFolderPath != NULL &&
+ SUCCEEDED( dSHGetFolderPath( NULL, /*CSIDL_COMMON_APPDATA*/ 0x0023,
+ NULL, 0, p_tmp ) ) )
+ {
+ strncat( p_tmp, p_filename, min( strlen( p_filename ),
+ (sizeof(p_tmp)/sizeof(p_tmp[0]) - 1) -
+ strlen( p_tmp ) ) );
+ psz_path = p_tmp;
+ }
+
+ if( shfolder_dll != NULL )
+ {
+ FreeLibrary( shfolder_dll );
+ }
+#endif
+ }
+ else
+ {
+#define ISCINFO "iSCInfo"
+ if( strstr( psz_ipod, ISCINFO ) == NULL )
+ {
+ sprintf( p_tmp, /*sizeof(p_tmp)/sizeof(p_tmp[0]) - 1,*/
+ "%s/iPod_Control/iTunes/" ISCINFO, psz_ipod );
+ psz_path = p_tmp;
+ }
+ else
+ {
+ psz_path = psz_ipod;
+ }
+ }
+
+ if( psz_path == NULL )
+ {
+ return -1;
+ }
+
+ file = fopen( psz_path, "r" );
+ if( file != NULL )
+ {
+ struct stat st;
+
+ if( !fstat( fileno( file ), &st ) )
+ {
+ *pp_sci = malloc( st.st_size );
+ if( *pp_sci != NULL )
+ {
+ if( fread( *pp_sci, 1, st.st_size,
+ file ) == (size_t)st.st_size )
+ {
+ *pi_sci_size = st.st_size;
+ i_ret = 0;
+ }
+ else
+ {
+ free( (void *)*pp_sci );
+ *pp_sci = NULL;
+ }
+ }
+ }
+
+ fclose( file );
+ }
+
+ return i_ret;
+}
+
+/*****************************************************************************
+ * HashSystemInfo: hash system information
+ *****************************************************************************
+ * This function computes the MD5 hash of the C: hard drive serial number,
+ * BIOS version, CPU type and Windows version.
+ *****************************************************************************/
+static int HashSystemInfo( uint32_t *p_system_hash )
+{
+ struct md5_s md5;
+ int i_ret = 0;
+
+#ifdef _WIN32
+ HKEY i_key;
+ unsigned int i;
+ DWORD i_size;
+ DWORD i_serial;
+ LPBYTE p_reg_buf;
+
+ static LPCTSTR p_reg_keys[ 3 ][ 2 ] =
+ {
+ {
+ _T("HARDWARE\\DESCRIPTION\\System"),
+ _T("SystemBiosVersion")
+ },
+
+ {
+ _T("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),
+ _T("ProcessorNameString")
+ },
+
+ {
+ _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion"),
+ _T("ProductId")
+ }
+ };
+
+ InitMD5( &md5 );
+
+ AddMD5( &md5, "cache-control", 13 );
+ AddMD5( &md5, "Ethernet", 8 );
+
+ GetVolumeInformation( _T("C:\\"), NULL, 0, &i_serial,
+ NULL, NULL, NULL, 0 );
+ AddMD5( &md5, (uint8_t *)&i_serial, 4 );
+
+ for( i = 0; i < sizeof(p_reg_keys) / sizeof(p_reg_keys[ 0 ]); i++ )
+ {
+ if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, p_reg_keys[ i ][ 0 ],
+ 0, KEY_READ, &i_key ) != ERROR_SUCCESS )
+ {
+ continue;
+ }
+
+ if( RegQueryValueEx( i_key, p_reg_keys[ i ][ 1 ],
+ NULL, NULL, NULL, &i_size ) != ERROR_SUCCESS )
+ {
+ RegCloseKey( i_key );
+ continue;
+ }
+
+ p_reg_buf = malloc( i_size );
+
+ if( p_reg_buf != NULL )
+ {
+ if( RegQueryValueEx( i_key, p_reg_keys[ i ][ 1 ],
+ NULL, NULL, p_reg_buf,
+ &i_size ) == ERROR_SUCCESS )
+ {
+ AddMD5( &md5, (uint8_t *)p_reg_buf, i_size );
+ }
+
+ free( p_reg_buf );
+ }
+
+ RegCloseKey( i_key );
+ }
+
+#else
+ InitMD5( &md5 );
+ i_ret = -1;
+#endif
+
+ EndMD5( &md5 );
+ memcpy( p_system_hash, md5.p_digest, 16 );
+
+ return i_ret;
+}
+
+/*****************************************************************************
+ * GetiPodID: Get iPod ID
+ *****************************************************************************
+ * This function gets the iPod ID.
+ *****************************************************************************/
+static int GetiPodID( int64_t *p_ipod_id )
+{
+ int i_ret = -1;
+
+#define PROD_NAME "iPod"
+#define VENDOR_NAME "Apple Computer, Inc."
+
+ char *psz_ipod_id = getenv( "IPODID" );
+ if( psz_ipod_id != NULL )
+ {
+#ifndef _WIN32
+ *p_ipod_id = strtoll( psz_ipod_id, NULL, 16 );
+#else
+ *p_ipod_id = strtol( psz_ipod_id, NULL, 16 );
+#endif
+ return 0;
+ }
+
+#ifdef HAVE_IOKIT_IOKITLIB_H
+ CFTypeRef value;
+ mach_port_t port;
+ io_object_t device;
+ io_iterator_t iterator;
+ CFMutableDictionaryRef matching_dic;
+
+ if( IOMasterPort( MACH_PORT_NULL, &port ) == KERN_SUCCESS )
+ {
+ if( ( matching_dic = IOServiceMatching( "IOFireWireUnit" ) ) != NULL )
+ {
+ CFDictionarySetValue( matching_dic,
+ CFSTR("FireWire Vendor Name"),
+ CFSTR(VENDOR_NAME) );
+ CFDictionarySetValue( matching_dic,
+ CFSTR("FireWire Product Name"),
+ CFSTR(PROD_NAME) );
+
+ if( IOServiceGetMatchingServices( port, matching_dic,
+ &iterator ) == KERN_SUCCESS )
+ {
+ while( ( device = IOIteratorNext( iterator ) ) != NULL )
+ {
+ value = IORegistryEntryCreateCFProperty( device,
+ CFSTR("GUID"), kCFAllocatorDefault, kNilOptions );
+
+ if( value != NULL )
+ {
+ if( CFGetTypeID( value ) == CFNumberGetTypeID() )
+ {
+ int64_t i_ipod_id;
+ CFNumberGetValue( (CFNumberRef)value,
+ kCFNumberLongLongType,
+ &i_ipod_id );
+ *p_ipod_id = i_ipod_id;
+ i_ret = 0;
+ }
+
+ CFRelease( value );
+ }
+
+ IOObjectRelease( device );
+
+ if( !i_ret ) break;
+ }
+
+ IOObjectRelease( iterator );
+ }
+ }
+
+ mach_port_deallocate( mach_task_self(), port );
+ }
+
+#elif HAVE_SYSFS_LIBSYSFS_H
+ struct sysfs_bus *bus = NULL;
+ struct dlist *devlist = NULL;
+ struct dlist *attributes = NULL;
+ struct sysfs_device *curdev = NULL;
+ struct sysfs_attribute *curattr = NULL;
+
+ bus = sysfs_open_bus( "ieee1394" );
+ if( bus != NULL )
+ {
+ devlist = sysfs_get_bus_devices( bus );
+ if( devlist != NULL )
+ {
+ dlist_for_each_data( devlist, curdev, struct sysfs_device )
+ {
+ attributes = sysfs_get_device_attributes( curdev );
+ if( attributes != NULL )
+ {
+ dlist_for_each_data( attributes, curattr,
+ struct sysfs_attribute )
+ {
+ if( ( strcmp( curattr->name, "model_name" ) == 0 ) &&
+ ( strncmp( curattr->value, PROD_NAME,
+ sizeof(PROD_NAME) ) == 0 ) )
+ {
+ *p_ipod_id = strtoll( curdev->name, NULL, 16 );
+ i_ret = 0;
+ break;
+ }
+ }
+ }
+
+ if( !i_ret ) break;
+ }
+ }
+
+ sysfs_close_bus( bus );
+ }
+#endif
+
+ return i_ret;
+}
+
+#endif

Added: trunk/Tests/avcdecodetest/mp4ff/src/mp4atom.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/src/mp4atom.c Sun Apr 6 05:36:03 2008
@@ -0,0 +1,981 @@
+/*
+** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
+** Copyright (C) 2003-2005 M. Bakker, Nero 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.
+**
+** Software using this code must display the following message visibly in or
+** on each copy of the software:
+** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Nero AG, www.nero.com"
+** in, for example, the about-box or help/startup screen.
+**
+** Commercial non-GPL licensing of this software is possible.
+** For more info contact Nero AG through Mpeg4AA...@nero.com.
+**
+** $Id: mp4atom.c,v 1.23 2006/05/07 18:09:00 menno Exp $
+**/
+
+#include <stdlib.h>
+#ifndef _WIN32
+#include "config.h"
+#else
+#include <tchar.h>
+#ifdef ITUNES_DRM
+#include <shlobj.h>
+#endif
+#include <windows.h>
+#endif
+#ifdef HAVE_GETPWUID
+# include <pwd.h>
+#endif
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+#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, 'a','v','c','1'))
+ return ATOM_AVC1;
+ else if (mp4ff_atom_compare(a,b,c,d, 'a','v','c','C'))
+ return ATOM_AVCC;
+ else 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 if (mp4ff_atom_compare(a,b,c,d, 'u','s','e','r'))
+ return ATOM_USER;
+ else if (mp4ff_atom_compare(a,b,c,d, 'k','e','y',' '))
+ return ATOM_KEY;
+ 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;
+}
+
+static int32_t mp4ff_read_avcc(mp4ff_t *f)
+{
+ mp4ff_read_char(f); /* configurationVersion */
+ mp4ff_read_char(f); /* AVCProfileIndication */
+ mp4ff_read_char(f); /* profile_compatibility */
+ mp4ff_read_char(f); /* AVCLevelIndication */
+ mp4ff_read_char(f); /* reserved(6bits) & lengthSizeMinusOne(2bits) */
+ mp4ff_read_char(f); /* reserved1(3bits) & numOfSequenceParameterSets(5bits) */
+
+ f->track[f->total_tracks - 1]->avc_sps_size = mp4ff_read_int16(f);
+ f->track[f->total_tracks - 1]->avc_sps = (uint8_t*)malloc(f->track[f->total_tracks - 1]->avc_sps_size);
+ if ( f->track[f->total_tracks - 1]->avc_sps ) {
+ mp4ff_read_data(f, f->track[f->total_tracks - 1]->avc_sps, f->track[f->total_tracks - 1]->avc_sps_size);
+ } else {
+ f->track[f->total_tracks - 1]->avc_sps_size = 0;
+ return 0;
+ }
+ mp4ff_read_char(f); /* numOfPictureParameterSets */
+ f->track[f->total_tracks - 1]->avc_pps_size = mp4ff_read_int16(f);
+ f->track[f->total_tracks - 1]->avc_pps = (uint8_t*)malloc(f->track[f->total_tracks - 1]->avc_pps_size);
+ if ( f->track[f->total_tracks - 1]->avc_pps ) {
+ mp4ff_read_data(f, f->track[f->total_tracks - 1]->avc_pps, f->track[f->total_tracks - 1]->avc_pps_size);
+ } else {
+ f->track[f->total_tracks - 1]->avc_pps_size = 0;
+ return 0;
+ }
+ return 0;
+}
+
+static int32_t mp4ff_read_mp4v(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 */
+ mp4ff_read_int32(f); /* reserved */
+ mp4ff_read_int32(f); /* reserved */
+
+ f->track[f->total_tracks - 1]->width = mp4ff_read_int16(f);
+ f->track[f->total_tracks - 1]->height = mp4ff_read_int16(f);
+
+ for (i = 0; i < 14; i++)
+ {
+ mp4ff_read_char(f); /* reserved */
+ }
+
+ for (i = 0; i < 32; i++)
+ {
+ mp4ff_read_char(f); /* compressorName */
+ }
+ mp4ff_read_int32(f); /* reserved */
+
+ size = mp4ff_atom_read_header(f, &atom_type, &header_size);
+ if (atom_type == ATOM_AVCC)
+ {
+ mp4ff_read_avcc(f);
+ }
+
+ return 0;
+}
+
+#ifdef ITUNES_DRM
+char *GetHomeDir( void )
+{
+ char *p_tmp, *p_homedir = NULL;
+
+#if defined(HAVE_GETPWUID)
+ struct passwd *p_pw = NULL;
+#endif
+
+#if defined(_WIN32) || defined(UNDER_CE)
+ typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,
+ LPSTR );
+# define CSIDL_FLAG_CREATE 0x8000
+# define CSIDL_APPDATA 0x1A
+# define SHGFP_TYPE_CURRENT 0
+
+ HINSTANCE shfolder_dll;
+ SHGETFOLDERPATH SHGetFolderPath ;
+ /* load the shfolder dll to retrieve SHGetFolderPath */
+ if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )
+ {
+ SHGetFolderPath = (void *)GetProcAddress( shfolder_dll,
+ _T("SHGetFolderPathA") );
+ if ( SHGetFolderPath != NULL )
+ {
+ p_homedir = (char *)malloc( MAX_PATH );
+ if( !p_homedir )
+ {
+ return NULL;
+ }
+
+ /* get the "Application Data" folder for the current user */
+ if( S_OK == SHGetFolderPath( NULL,
+ CSIDL_APPDATA | CSIDL_FLAG_CREATE,
+ NULL, SHGFP_TYPE_CURRENT,
+ p_homedir ) )
+ {
+ FreeLibrary( shfolder_dll );
+ return p_homedir;
+ }
+ free( p_homedir );
+ }
+ FreeLibrary( shfolder_dll );
+ }
+#endif
+
+#if defined(HAVE_GETPWUID)
+ if( ( p_pw = getpwuid( getuid() ) ) == NULL )
+#endif
+ {
+ if( ( p_tmp = getenv( "HOME" ) ) == NULL )
+ {
+ if( ( p_tmp = getenv( "TMP" ) ) == NULL )
+ {
+ p_tmp = "/tmp";
+ }
+ }
+
+ p_homedir = strdup( p_tmp );
+ }
+#if defined(HAVE_GETPWUID)
+ else
+ {
+ p_homedir = strdup( p_pw->pw_dir );
+ }
+#endif
+
+ return p_homedir;
+}
+
+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;
+
+ f->track[f->total_tracks - 1]->p_drms = drms_alloc( GetHomeDir() );
+
+ 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,0);
+ }
+
+ 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,
+ FOURCC_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,
+ FOURCC_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,
+ FOURCC_iviv, data, sizeof(uint32_t) * 4 );
+ }
+
+ if (data)
+ free(data);
+
+ return 0;
+}
+
+static int32_t mp4ff_read_user(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,
+ FOURCC_user, data, size );
+ }
+
+ if (data)
+ free(data);
+
+ return 0;
+}
+
+static int32_t mp4ff_read_key(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,
+ FOURCC_key, data, size );
+ }
+
+ 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 || atom_type == ATOM_AVC1) {
+ f->track[f->total_tracks - 1]->type = TRACK_VIDEO;
+ mp4ff_read_mp4v(f);
+ } 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-(header_size+4)))
+ {
+ subsize = mp4ff_atom_read_header(f, &atom_type, &header_size);
+ if (subsize <= header_size+4)
+ return 1;
+ 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);
+ } else if (atom_type == ATOM_USER) {
+ mp4ff_read_user(f, size-8);
+ } else if (atom_type == ATOM_KEY) {
+ mp4ff_read_key(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;
+}

Added: trunk/Tests/avcdecodetest/mp4ff/src/mp4ff.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/src/mp4ff.c Sun Apr 6 05:36:03 2008
@@ -0,0 +1,516 @@
+/*
+** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
+** Copyright (C) 2003-2005 M. Bakker, Nero 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.
+**
+** Software using this code must display the following message visibly in or
+** on each copy of the software:
+** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Nero AG, www.nero.com"
+** in, for example, the about-box or help/startup screen.
+**
+** Commercial non-GPL licensing of this software is possible.
+** For more info contact Nero AG through Mpeg4AA...@nero.com.
+**
+** $Id: mp4ff.c,v 1.18 2006/05/07 18:09:00 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,0);
+
+ return ff;
+}
+
+mp4ff_t *mp4ff_open_read_metaonly(mp4ff_callback_t *f)
+{
+ mp4ff_t *ff = malloc(sizeof(mp4ff_t));
+
+ memset(ff, 0, sizeof(mp4ff_t));
+
+ ff->stream = f;
+
+ parse_atoms(ff,1);
+
+ 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);
+ if (ff->track[i]->avc_sps)
+ free(ff->track[i]->avc_sps);
+ if (ff->track[i]->avc_pps)
+ free(ff->track[i]->avc_pps);
+#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));
+}
+
+static int need_parse_when_meta_only(uint8_t atom_type)
+{
+ switch(atom_type)
+ {
+ case ATOM_EDTS:
+// case ATOM_MDIA:
+// case ATOM_MINF:
+ case ATOM_DRMS:
+ case ATOM_SINF:
+ case ATOM_SCHI:
+// case ATOM_STBL:
+// case ATOM_STSD:
+ case ATOM_STTS:
+ case ATOM_STSZ:
+ case ATOM_STZ2:
+ case ATOM_STCO:
+ case ATOM_STSC:
+// case ATOM_CTTS:
+ case ATOM_FRMA:
+ case ATOM_IVIV:
+ case ATOM_PRIV:
+ return 0;
+ default:
+ return 1;
+ }
+}
+
+/* parse atoms that are sub atoms of other atoms */
+int32_t parse_sub_atoms(mp4ff_t *f, const uint64_t total_size,int meta_only)
+{
+ 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 (meta_only && !need_parse_when_meta_only(atom_type))
+ {
+ mp4ff_set_position(f, mp4ff_position(f)+size-header_size);
+ } else if (atom_type < SUBATOMIC)
+ {
+ parse_sub_atoms(f, size-header_size,meta_only);
+ } else {
+ mp4ff_atom_read(f, (uint32_t)size, atom_type);
+ }
+ }
+
+ return 0;
+}
+
+/* parse root atoms */
+int32_t parse_atoms(mp4ff_t *f,int meta_only)
+{
+ 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 (meta_only && !need_parse_when_meta_only(atom_type))
+ {
+ mp4ff_set_position(f, mp4ff_position(f)+size-header_size);
+ } else if (atom_type < SUBATOMIC)
+ {
+ parse_sub_atoms(f, size-header_size,meta_only);
+ } else {
+ /* skip this atom */
+ mp4ff_set_position(f, mp4ff_position(f)+size-header_size);
+ }
+ }
+
+ return 0;
+}
+
+int32_t mp4ff_get_avc_sps_pps(const mp4ff_t *f, const track, unsigned char** buffer, unsigned int* sps_size, unsigned int* pps_size)
+{
+ if (track >= f->total_tracks)
+ {
+ *buffer = NULL;
+ *sps_size = 0;
+ *pps_size = 0;
+ return 1;
+ }
+ if (f->track[track]->avc_sps == NULL || f->track[track]->avc_sps_size == 0 || f->track[track]->avc_pps == NULL || f->track[track]->avc_pps_size == 0)
+ {
+ *buffer = NULL;
+ *sps_size = 0;
+ *pps_size = 0;
+ }
+ else
+ {
+ *buffer = malloc(f->track[track]->avc_sps_size+f->track[track]->avc_pps_size);
+ if (*buffer == NULL)
+ {
+ *sps_size = 0;
+ *pps_size = 0;
+ return 1;
+ }
+ memcpy(*buffer, f->track[track]->avc_sps, f->track[track]->avc_sps_size);
+ memcpy((*buffer)+f->track[track]->avc_sps_size, f->track[track]->avc_pps, f->track[track]->avc_pps_size);
+ *sps_size = f->track[track]->avc_sps_size;
+ *pps_size = f->track[track]->avc_pps_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;
+}

Added: trunk/Tests/avcdecodetest/mp4ff/src/mp4meta.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/src/mp4meta.c Sun Apr 6 05:36:03 2008
@@ -0,0 +1,433 @@
+/*
+** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
+** Copyright (C) 2003-2005 M. Bakker, Nero 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.
+**
+** Software using this code must display the following message visibly in or
+** on each copy of the software:
+** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Nero AG, www.nero.com"
+** in, for example, the about-box or help/startup screen.
+**
+** Commercial non-GPL licensing of this software is possible.
+** For more info contact Nero AG through Mpeg4AA...@nero.com.
+**
+** $Id: mp4meta.c,v 1.17 2006/05/07 18:09:00 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);
+ if (subsize == 0)
+ break;
+ 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_totaltracks(const mp4ff_t *f, char **value)
+{
+ return mp4ff_meta_find_by_name(f, "totaltracks", 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_totaldiscs(const mp4ff_t *f, char **value)
+{
+ return mp4ff_meta_find_by_name(f, "totaldiscs", 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
\ No newline at end of file

Added: trunk/Tests/avcdecodetest/mp4ff/src/mp4sample.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/src/mp4sample.c Sun Apr 6 05:36:03 2008
@@ -0,0 +1,157 @@
+/*
+** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
+** Copyright (C) 2003-2005 M. Bakker, Nero 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.
+**
+** Software using this code must display the following message visibly in or
+** on each copy of the software:
+** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Nero AG, www.nero.com"
+** in, for example, the about-box or help/startup screen.
+**
+** Commercial non-GPL licensing of this software is possible.
+** For more info contact Nero AG through Mpeg4AA...@nero.com.
+**
+** $Id: mp4sample.c,v 1.18 2006/05/07 18:09:00 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;
+}

Added: trunk/Tests/avcdecodetest/mp4ff/src/mp4tagupdate.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/src/mp4tagupdate.c Sun Apr 6 05:36:03 2008
@@ -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"))
+ {
+ 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,1);
+
+
+ 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

Added: trunk/Tests/avcdecodetest/mp4ff/src/mp4util.c
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mp4ff/src/mp4util.c Sun Apr 6 05:36:03 2008
@@ -0,0 +1,193 @@
+/*
+** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
+** Copyright (C) 2003-2005 M. Bakker, Nero 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.
+**
+** Software using this code must display the following message visibly in or
+** on each copy of the software:
+** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Nero AG, www.nero.com"
+** in, for example, the about-box or help/startup screen.
+**
+** Commercial non-GPL licensing of this software is possible.
+** For more info contact Nero AG through Mpeg4AA...@nero.com.
+**
+** $Id: mp4util.c,v 1.18 2006/05/07 18:09:00 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;
+}

Added: trunk/Tests/avcdecodetest/mpegbase.S
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/mpegbase.S Sun Apr 6 05:36:03 2008
@@ -0,0 +1,10 @@
+ .set noreorder
+
+#include "pspimport.s"
+
+ IMPORT_START "sceMpegbase",0x00090000
+ IMPORT_FUNC "sceMpegbase",0xBE45C284,sceMpegBaseYCrCbCopyVme
+ IMPORT_FUNC "sceMpegbase",0x492B5E4B,sceMpegBaseCscInit
+ IMPORT_FUNC "sceMpegbase",0xCE8EB837,sceMpegBaseCscVme
+ IMPORT_FUNC "sceMpegbase",0x91929A21,sceMpegBaseCscAvc
+ IMPORT_FUNC "sceMpegbase",0xBEA18F91,sceMpegbase_BEA18F91

Added: trunk/Tests/avcdecodetest/pspmpeg/Makefile
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/pspmpeg/Makefile Sun Apr 6 05:36:03 2008
@@ -0,0 +1,21 @@
+PSPSDK=$(shell psp-config --pspsdk-path)
+MPEG_OBJS = sceMpeg.o sceMpeg_0000.o sceMpeg_0001.o sceMpeg_0002.o sceMpeg_0003.o sceMpeg_0004.o sceMpeg_0005.o \
+ sceMpeg_0006.o sceMpeg_0007.o sceMpeg_0008.o sceMpeg_0009.o sceMpeg_0010.o \
+ sceMpeg_0011.o sceMpeg_0012.o sceMpeg_0013.o sceMpeg_0014.o sceMpeg_0015.o \
+ sceMpeg_0016.o sceMpeg_0017.o sceMpeg_0018.o sceMpeg_0019.o sceMpeg_0020.o \
+ sceMpeg_0021.o sceMpeg_0022.o sceMpeg_0023.o sceMpeg_0024.o sceMpeg_0025.o \
+ sceMpeg_0026.o sceMpeg_0027.o sceMpeg_0028.o sceMpeg_0029.o sceMpeg_0030.o \
+ sceMpeg_0031.o sceMpeg_0032.o sceMpeg_0033.o sceMpeg_0034.o sceMpeg_0035.o \
+ sceMpeg_0036.o sceMpeg_0037.o sceMpeg_0038.o sceMpeg_0039.o sceMpeg_0040.o \
+ sceMpeg_0041.o sceMpeg_0042.o
+
+%.o: sceMpeg.S
+ psp-gcc -g -O2 -G0 -Wall -I${PSPSDK}/include -DF_$* $< -c -o $@
+
+all: $(MPEG_OBJS)
+ psp-ar cru ../libpspmpeg.a $(MPEG_OBJS)
+ psp-ranlib ../libpspmpeg.a
+
+clean:
+ rm -f *.o
+ rm -f ../libpspmpeg.a

Added: trunk/Tests/avcdecodetest/pspmpeg/pspmpeg.h
==============================================================================
--- (empty file)
+++ trunk/Tests/avcdecodetest/pspmpeg/pspmpeg.h Sun Apr 6 05:36:03 2008
@@ -0,0 +1,329 @@
+/*
+ * pspmpeg.h - Prototypes for the sceMpeg library.
+ *
+ * Copyright (c) 2006 Sorin P. C. <ma...@hypermagik.com>
+ */
+
+#ifndef __SCELIBMPEG_H__
+#define __SCELIBMPEG_H__
+
+#include <psptypes.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** points to "LIBMPEG" */
+typedef ScePVoid SceMpeg;
+
+/** some structure */
+typedef SceVoid SceMpegStream;
+
+/** Ringbuffer callback */
+typedef SceInt32 (*sceMpegRingbufferCB)(ScePVoid pData, SceInt32 iNumPackets, ScePVoid pParam);
+
+typedef struct SceMpegRingbuffer
+{
+ /** packets */
+ SceInt32 iPackets;
+
+ /** unknown */
+ SceUInt32 iUnk0;
+ /** unknown */
+ SceUInt32 iUnk1;
+ /** unknown */
+ SceUInt32 iUnk2;
+ /** unknown */
+ SceUInt32 iUnk3;
+
+ /** pointer to data */
+ ScePVoid pData;
+
+ /** ringbuffer callback */
+ sceMpegRingbufferCB Callback;
+ /** callback param */
+ ScePVoid pCBparam;
+
+ /** unknown */
+ SceUInt32 iUnk4;
+ /** unknown */
+ SceUInt32 iUnk5;
+ /** mpeg id */
+ SceMpeg pSceMpeg;
+
+} SceMpegRingbuffer;
+
+typedef struct SceMpegAu
+{
+ /** unknown */
+ SceUInt32 iUnk0;
+ /** presentation timestamp? */
+ SceInt32 iTimestamp;
+ /** unknown */
+ SceUInt32 iUnk1;
+ /** unknown */
+ SceUInt32 iUnk2;
+ /** Es buffer handle */
+ SceUInt32 iEsBuffer;
+ /** Au size */
+ SceUInt32 iAuSize;
+
+} SceMpegAu;
+
+typedef struct SceMpegAvcMode
+{
+ /** unknown, set to -1 */
+ SceInt32 iUnk0;
+ /** unknonw, set to 3 */
+ SceInt32 iUnk1;
+
+} SceMpegAvcMode;
+
+/**
+ * sceMpegInit
+ *
+ * @returns 0 if success.
+ */
+SceInt32 sceMpegInit();
+
+/**
+ * sceMpegFinish
+ */
+SceVoid sceMpegFinish();
+
+/**
+ * sceMpegRingbufferQueryMemSize
+ *
+ * @param iPackets - number of packets in the ringbuffer
+ *
+ * @returns < 0 if error else ringbuffer data size.
+ */
+SceInt32 sceMpegRingbufferQueryMemSize(SceInt32 iPackets);
+
+/**
+ * sceMpegRingbufferConstruct
+ *
+ * @param Ringbuffer - pointer to a sceMpegRingbuffer struct
+ * @param iPackets - number of packets in the ringbuffer
+ * @param pData - pointer to allocated memory
+ * @param iSize - size of allocated memory, shoud be sceMpegRingbufferQueryMemSize(iPackets)
+ * @param Callback - ringbuffer callback
+ * @param pCBparam - param passed to callback
+ *
+ * @returns 0 if success.
+ */
+SceInt32 sceMpegRingbufferConstruct(SceMpegRingbuffer* Ringbuffer, SceInt32 iPackets, ScePVoid pData, SceInt32 iSize, sceMpegRingbufferCB Callback, ScePVoid pCBparam);
+
+/**
+ * sceMpegRingbufferDestruct
+ *
+ * @param Ringbuffer - pointer to a sceMpegRingbuffer struct
+ */
+SceVoid sceMpegRingbufferDestruct(SceMpegRingbuffer* Ringbuffer);
+
+/**
+ * sceMpegQueryMemSize
+ *
+ * @param Ringbuffer - pointer to a sceMpegRingbuffer struct
+ *
+ * @returns < 0 if

==============================================================================
Diff truncated at 200k characters