cooleyes's devlog http://cooleyes.fx-world.org/blog Mon, 09 Feb 2009 01:16:00 +0000 http://wordpress.org/?v=2.7.1 en hourly 1 a new sample to decode all psp supported MP4AVC http://cooleyes.fx-world.org/blog/?p=16 http://cooleyes.fx-world.org/blog/?p=16#comments Mon, 09 Feb 2009 01:15:35 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=16 Here is a sample code to decode a psp mp4(avc) file.
it can decode baseline profile MP4AVC(<=480*272),
it also can decode main profile MP4AVC(<=720*480)

full source package, you can download from here
http://cooleyes.fx-world.org/downloads/samples/avcdecoder.rar

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=16 PMPlayer advance built(20090205-en) release http://cooleyes.fx-world.org/blog/?p=15 http://cooleyes.fx-world.org/blog/?p=15#comments Sat, 07 Feb 2009 00:03:45 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=15
[changelog]

Happy niu year!
1. PSP&IPhone MP4AVC suppported (<=480*272)
2. ISO8859-6 charset supported, ISO8859-9 charset supported(update miniconv.prx to miniconv.eur.prx.20090206)
3. 480P MP4AVC will come next release :P
[download]
http://code.google.com/p/pmplayer-advance/downloads/list

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=15 PMPlayer advance built(20081018-en) release http://cooleyes.fx-world.org/blog/?p=14 http://cooleyes.fx-world.org/blog/?p=14#comments Sun, 19 Oct 2008 01:21:12 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=14
[changelog]

1. fw5.00M33 supported.
2. xxx.sc.srt, xxx.tc.srt subtitles supported, sc is GBK, tc is BIG5
3. can play rotate 180, press X+Start when playing
[download]
http://code.google.com/p/pmplayer-advance/downloads/list

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=14 PMPlayer advance built(20080902-en) release http://cooleyes.fx-world.org/blog/?p=13 http://cooleyes.fx-world.org/blog/?p=13#comments Tue, 02 Sep 2008 03:12:31 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=13
[changelog]

1. clean all fw1xx code from source
2. fw4.01M33 supported.
3. xxx.eng.srt, xxx.cht.srt, xxx.chs.srt，。。。， such as these srt subtitles supported
4. fixed codeset bugs for sub file(microdvd subtitle)
5. MP4(xvid+aac) supported
6. use a new file “moviestat.dat” to instead of “*.pos” file, it can saved 20 records.

[download]
http://code.google.com/p/pmplayer-advance/downloads/list

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=13 Convert PMF to MP4AVC http://cooleyes.fx-world.org/blog/?p=12 http://cooleyes.fx-world.org/blog/?p=12#comments Mon, 14 Jul 2008 04:57:56 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=12 Convert PMF to MP4AVC, we must recompress video data and audio data.

some software is required :
 1 Sony’s SonicStage
2 AviSynth
3 a MKV splitter
4 a AVC decoder

now you can convert pmf to mp4avc like :

1.  PMFVideoDumper.exe  in.pmf
2.  PMFAudioDumper.exe  in.pmf
3.  HIMDRENDER.exe -i in.pmf.0.oma -o in.pmf.0.wav ( you can use all tracks or just one)
4.  neroAacEnc_SSE2.exe -br 128000 -if in.pmf.0.wav -of in.pmf.0.m4a
5.  mkvmerge -o "in.pmf.mkv"  –default-duration 0:30000/1001fps -d 0 -A -S "in.pmf.264" –track-order 0:0
6.  edit a avs file (in.pmf.avs), it’s content like "  directshowsource("in.pmf.mkv", audio=false)  "
7.  you can use Q mode or 2pass to encode a avc stream
    x264.exe  –pass 1 –bitrate 768 -A all –stats ".stats" –level 3 –aud –bframes 3 –no-psnr –threads auto –no-psnr –thread-input –progress –output NUL "in.pmf.avs"
    x264.exe  –pass 2 –bitrate 768 -A all –stats ".stats" –level 3 –aud –bframes 3 –no-psnr –threads auto –no-psnr –thread-input –progress –output in.pmf.recompress.264 "in.pmf.avs"

8. using MP4Box to mux avc and aac stream into a MP4 file
    MP4Box -fps 29.97 -add in.pmf.recompress.264 out.mp4
    MP4Box -fps 29.97 -add in.pmf.0.m4a out.mp4

all tools, you can download it here
http://www.fx-world.org/cooleyes/downloads/tools/PMF2MP4-20080714.rar

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=12 Update PMF2PMP to 20080712 http://cooleyes.fx-world.org/blog/?p=11 http://cooleyes.fx-world.org/blog/?p=11#comments Sat, 12 Jul 2008 07:33:53 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=11 【Changelog】
1.fixed PMFAudioDumper, can dump more audio tracks from PMF file

【Download】

http://www.fx-world.org/cooleyes/downloads/tools/PMF2PMP-20080712.rar

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=11 Convert PMF to PMP quickly http://cooleyes.fx-world.org/blog/?p=10 http://cooleyes.fx-world.org/blog/?p=10#comments Thu, 19 Jun 2008 09:19:47 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=10 you must have installed Sony’s SonicStage

1.  PMFVideoDumper.exe  in.pmf
2.  PMFAudioDumper.exe  in.pmf
3.  HIMDRENDER.exe -i in.pmf.oma -o in.pmf.wav
4.  neroAacEnc_SSE2.exe -br 128000 -if in.pmf.wav -of in.pmf.m4a
5.  pmp_muxer2.exe -v in.pmf.264 -a in.pmf.m4a -o out.pmp -d 1 -w 480 -h 272 -r 30000 -s 1001
6.  del in.pmf.264
     del in.pmf.oma
     del in.pmf.wav
     del in.pmf.m4a

all tools, you can download it here

http://www.fx-world.org/cooleyes/downloads/tools/PMF2PMP-20080619.rar

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=10 PMPlayer advance svn update(20080613) http://cooleyes.fx-world.org/blog/?p=9 http://cooleyes.fx-world.org/blog/?p=9#comments Fri, 13 Jun 2008 02:18:10 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=9 submit some new code to svn today,
add MP4(xvid) supported to PPA,
but the play fps is still not full, :(

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=9 PMPlayer advance built(20080608-en) release http://cooleyes.fx-world.org/blog/?p=8 http://cooleyes.fx-world.org/blog/?p=8#comments Wed, 11 Jun 2008 08:28:43 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=8
[changelog]

1. fw3.95GEN supported.
2. more MP4AVC file supported
3.ISO8859-1 charset supported  in English version release.

[download]
http://code.google.com/p/pmplayer-advance/downloads/list

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=8 a sample code to decode a psp mp4(avc) file http://cooleyes.fx-world.org/blog/?p=7 http://cooleyes.fx-world.org/blog/?p=7#comments Tue, 11 Mar 2008 08:11:33 +0000 cooleyes http://www.fx-world.org/cooleyes/?p=7 to decode mp4(avc), we need a mpeg_vsh.prx from psp fw (ver > 2.00)
so I use the mpeg_vsh.prx from psp fw(3.30),
I decompress and decrypt mpeg_vsh.prx from psp fw(3.30) and rename to mpeg_vsh330.prx , and use it to decode mp4(avc)

now, I can decode <=480*272 avc frame from psp mp4 file,
and I am trying to decode 720*480 avc frame from psp mp4 file.

[sample code]

C++ code
  1. /* 
  2.  *   Copyright (C) 2008 cooleyes 
  3.  *   eyes.cooleyes@gmail.com 
  4.  * 
  5.  *  This Program is free software; you can redistribute it and/or modify 
  6.  *  it under the terms of the GNU General Public License as published by 
  7.  *  the Free Software Foundation; either version 2, or (at your option) 
  8.  *  any later version. 
  9.  *    
  10.  *  This Program is distributed in the hope that it will be useful, 
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
  13.  *  GNU General Public License for more details. 
  14.  *    
  15.  *  You should have received a copy of the GNU General Public License 
  16.  *  along with GNU Make; see the file COPYING.  If not, write to 
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html 
  19.  * 
  20.  */  
  21. #include <pspkernel.h>  
  22. #include <pspctrl.h>  
  23. #include <pspdisplay.h>  
  24. #include <psputils.h>  
  25. #include <pspgu.h>  
  26. #include <pspdebug.h>  
  27. #include <psppower.h>  
  28. #include <stdio.h>  
  29. #include <stdlib.h>  
  30. #include <psprtc.h>  
  31. #include <pspsdk.h>  
  32. #include <string.h>  
  33. #include <malloc.h>  
  34. #include "mem64.h"  
  35. #include "pspmpeg/pspmpeg.h"  
  36. #include "mp4ff.h"  
  37.   
  38. int SetupCallbacks();  
  39.   
  40. PSP_MODULE_INFO("avcdecode test", 0, 1, 1);  
  41. PSP_MAIN_THREAD_ATTR(0);  
  42. PSP_HEAP_SIZE_KB(18*1024);  
  43.   
  44. SceCtrlData input;  
  45.   
  46. typedef struct {  
  47.    ScePVoid sps_buffer;  
  48.    SceInt32 sps_size;  
  49.    ScePVoid pps_buffer;  
  50.    SceInt32 pps_size;  
  51.    SceInt32 unkown0;  
  52.    ScePVoid nal_buffer;  
  53.    SceInt32 nal_size;  
  54.    SceInt32 mode;  
  55. } AvcNalStruct;  
  56.   
  57. typedef struct {  
  58.    SceInt32 unknown0;  
  59.    SceInt32 unknown1;  
  60.    SceInt32 width;  
  61.    SceInt32 height;  
  62.    SceInt32 unknown4;  
  63.    SceInt32 unknown5;  
  64.    SceInt32 unknown6;  
  65.    SceInt32 unknown7;  
  66.    SceInt32 unknown8;  
  67.    SceInt32 unknown9;  
  68. } AvcInfoStruct;  
  69.   
  70. typedef struct {  
  71.    ScePVoid buffer0;  
  72.    ScePVoid buffer1;  
  73.    ScePVoid buffer2;  
  74.    ScePVoid buffer3;  
  75.    ScePVoid buffer4;  
  76.    ScePVoid buffer5;  
  77.    ScePVoid buffer6;  
  78.    ScePVoid buffer7;  
  79.    SceInt32 unknown0;  
  80.    SceInt32 unknown1;  
  81.    SceInt32 unknown2;  
  82. } AvcYuvStruct;  
  83.   
  84.   
  85. typedef struct {  
  86.    SceInt32 unknown0;  
  87.    SceInt32 unknown1;  
  88.    SceInt32 unknown2;  
  89.    SceInt32 unknown3;  
  90.    AvcInfoStruct* info_buffer;  
  91.    SceInt32 unknown5;  
  92.    SceInt32 unknown6;  
  93.    SceInt32 unknown7;  
  94.    SceInt32 unknown8;  
  95.    SceInt32 unknown9;  
  96.    SceInt32 unknown10;  
  97.    AvcYuvStruct* yuv_buffer;  
  98.    SceInt32 unknown12;  
  99.    SceInt32 unknown13;  
  100.    SceInt32 unknown14;  
  101.    SceInt32 unknown15;  
  102.    SceInt32 unknown16;  
  103.    SceInt32 unknown17;  
  104.    SceInt32 unknown18;  
  105.    SceInt32 unknown19;  
  106.    SceInt32 unknown20;  
  107.    SceInt32 unknown21;  
  108.    SceInt32 unknown22;  
  109.    SceInt32 unknown23;  
  110. } AvcCodecStruct;  
  111.   
  112. typedef struct {  
  113.    SceInt32 height;  
  114.    SceInt32 width;  
  115.    SceInt32 mode0;  
  116.    SceInt32 mode1;  
  117.    ScePVoid buffer0;  
  118.    ScePVoid buffer1;  
  119.    ScePVoid buffer2;  
  120.    ScePVoid buffer3;  
  121.    ScePVoid buffer4;  
  122.    ScePVoid buffer5;  
  123.    ScePVoid buffer6;  
  124.    ScePVoid buffer7;  
  125. } AvcCscStruct;  
  126.   
  127. typedef struct {  
  128.    ScePVoid mpeg_buffer;  
  129.    SceMpeg mpeg;  
  130.    SceMpegRingbuffer mpeg_ringbuffer;  
  131.    SceMpegAu* mpeg_au;  
  132.    SceInt32 mpeg_mode;  
  133.    SceInt32 mpeg_buffer_size;  
  134.    ScePVoid mpeg_ddrtop;  
  135.    ScePVoid mpeg_au_buffer;  
  136.    AvcNalStruct mpeg_nal;  
  137.    AvcCodecStruct* mpeg_codec_buffer;  
  138.    AvcYuvStruct* mpeg_yuv_buffer;  
  139.    AvcInfoStruct* mpeg_info_buffer;     
  140. } AvcDecodeStruct;  
  141.   
  142. static uint32_t mp4_read(void *user_data, void *buffer, uint32_t length) {  
  143.    FILE** fp = (FILE**)user_data;  
  144.    uint32_t res = fread(buffer, length, 1, *fp);  
  145.    return (res*length);  
  146. }  
  147.   
  148. static uint32_t mp4_seek(void *user_data, uint64_t position) {  
  149.    FILE** fp = (FILE**)user_data;  
  150.    return fseek(*fp, position, PSP_SEEK_SET );  
  151. }  
  152.   
  153. AvcDecodeStruct avc_struct;  
  154. AvcDecodeStruct* avc = &avc_struct;  
  155. AvcCscStruct csc_struct;  
  156. AvcCscStruct* csc = &csc_struct;  
  157. //unsigned char RGBBuffer[4*512*512];  
  158. unsigned char RGBBuffer0[4*512*272];  
  159. unsigned char RGBBuffer1[4*512*272];  
  160. unsigned char* FrameBuffer[] = {RGBBuffer0, RGBBuffer1};  
  161. int frame_index = 0;  
  162. char filename[1024];  
  163.   
  164. mp4ff_callback_t mp4_callback = {mp4_read, 0, mp4_seek, 0, 0};  
  165.   
  166. int main(void)  
  167. {  
  168.    SetupCallbacks();  
  169.      
  170.    pspDebugScreenInit();  
  171.    pspDebugScreenSetXY(0, 2);  
  172.    //scePowerSetClockFrequency(333,333,166);  
  173.    //scePowerSetCpuClockFrequency(333);  
  174.    //scePowerSetBusClockFrequency(166);  
  175.    scePowerSetClockFrequency(133,133,66);  
  176.    scePowerSetCpuClockFrequency(133);  
  177.    scePowerSetBusClockFrequency(66);  
  178.    u32 cpu = scePowerGetCpuClockFrequency();  
  179.    u32 bus = scePowerGetBusClockFrequency();  
  180.      
  181.    pspDebugScreenPrintf("cpu=%d, bus=%d\n", cpu, bus);  
  182.      
  183.    getcwd(filename, 256);  
  184.    strcat(filename, "/mpeg_vsh330.prx");  
  185.    pspDebugScreenPrintf("%s\n", filename);  
  186.      
  187.    FILE* mp4_file = fopen("ms0:/VIDEO/Test.MP4", "rb");  
  188.    mp4_callback.user_data = &mp4_file;  
  189.    mp4ff_t* mp4_handle = mp4ff_open_read(&mp4_callback);  
  190.    u32 total_tracks = mp4ff_total_tracks(mp4_handle);  
  191.    pspDebugScreenPrintf("total_tracks=%d\n", total_tracks);  
  192.    int ii;  
  193.    for(ii = 0; ii < total_tracks; ii++) {  
  194.       pspDebugScreenPrintf("track%d : type 0x%08X\n", ii, mp4ff_get_track_type(mp4_handle, ii));  
  195.       pspDebugScreenPrintf("track%d : %d samples\n", ii, mp4ff_num_samples(mp4_handle, ii));  
  196.    }  
  197.    u32 total_samples = mp4ff_num_samples(mp4_handle, 0);  
  198.    unsigned char* sps_pps_buffer;  
  199.    unsigned int sps_size, pps_size;  
  200.      
  201.    if ( mp4ff_get_avc_sps_pps(mp4_handle, 0, &sps_pps_buffer, &sps_size, &pps_size) != 0 || sps_size == 0 || pps_size == 0 )  {  
  202.       pspDebugScreenPrintf("\nerr: get_avc_sps_pps\n");  
  203.       goto wait;  
  204.    }  
  205.      
  206.    //pspDebugScreenPrintf("sps_size=%d, pps_size=%d\n", sps_size, pps_size);  
  207.      
  208.    int result;  
  209.    result = sceUtilityLoadAvModule(0);  
  210.    if ( result < 0 ) {  
  211.       pspDebugScreenPrintf("\nerr: sceUtilityLoadAvModule(0)\n");  
  212.       goto wait;  
  213.    }  
  214.      
  215.    SceUID modid;  
  216.    int status;  
  217.    modid = sceKernelLoadModule(filename, 0, NULL);  
  218.    if(modid >= 0) {  
  219.       modid = sceKernelStartModule(modid, 0, 0, &status, NULL);  
  220.    }  
  221.    else {  
  222.       pspDebugScreenPrintf("\nerr=0x%08X : sceKernelLoadModule\n", modid);  
  223.       goto wait;  
  224.    }  
  225.   
  226. //   result = pspSdkLoadStartModule("ms0:/mpeg_vsh330.prx", PSP_MEMORY_PARTITION_USER);  
  227. //   result = sceUtilityLoadAvModule(3);  
  228. //   if ( result < 0 ){  
  229. //      pspDebugScreenPrintf("\nerr=0x%08X : sceUtilityLoadAvModule(3)\n", result);  
  230. //      goto wait;  
  231. //   }  
  232.      
  233.    result = sceMpegInit();  
  234.    if ( result != 0 ){  
  235.       pspDebugScreenPrintf("\nerr: sceMpegInit\n");  
  236.       goto wait;  
  237.    }  
  238.      
  239.    avc->mpeg_mode = 4;  
  240. //   avc->mpeg_ddrtop = 0×09400000;  
  241. //   avc->mpeg_au_buffer = 0×09410000;  
  242.    avc->mpeg_ddrtop =  memalign(0×400000, 0×400000);  
  243.    avc->mpeg_au_buffer = avc->mpeg_ddrtop + 0×10000;  
  244.   
  245. //   pspDebugScreenPrintf("\naddress=0x%08X\n", avc->mpeg_au_buffer);  
  246.      
  247.      
  248.    result = sceMpegQueryMemSize(avc->mpeg_mode);  
  249.    if ( result < 0 ){  
  250.       pspDebugScreenPrintf("\nerr: sceMpegQueryMemSize(0x%08X)\n", avc->mpeg_mode);  
  251.       goto wait;  
  252.    }  
  253.      
  254. //   pspDebugScreenPrintf("\n%d\n", result);  
  255.      
  256.    avc->mpeg_buffer_size = result;  
  257.      
  258.    if ( (result & 0xF) != 0 )  
  259.       result = (result & 0xFFFFFFF0) + 16;  
  260.            
  261.    avc->mpeg_buffer = malloc_64(result);  
  262.    if ( avc->mpeg_buffer == 0 ) {  
  263.       pspDebugScreenPrintf("\nerr: alloc\n");  
  264.       goto wait;  
  265.    }  
  266.      
  267.    result = sceMpegCreate(&avc->mpeg, avc->mpeg_buffer, avc->mpeg_buffer_size, &avc->mpeg_ringbuffer, 512, avc->mpeg_mode, avc->mpeg_ddrtop);     
  268.    if ( result != 0){  
  269.       pspDebugScreenPrintf("\nerr: sceMpegCreate\n");  
  270.       goto wait;  
  271.    }  
  272.      
  273.    avc->mpeg_au = (SceMpegAu*)malloc_64(64);  
  274.    if ( avc->mpeg_au == 0 ) {  
  275.       pspDebugScreenPrintf("\nerr: alloc\n");  
  276.       goto wait;  
  277.    }  
  278.    memset(avc->mpeg_au, 0xFF, 64);  
  279.    if ( sceMpegInitAu(&avc->mpeg, avc->mpeg_au_buffer, avc->mpeg_au) != 0 ){  
  280.       pspDebugScreenPrintf("\nerr: sceMpegInitAu\n");  
  281.       goto wait;  
  282.    }  
  283.      
  284.    unsigned char* nal_buffer = (unsigned char*)malloc_64(1024*1024);  
  285.      
  286. //   unsigned char sps_pps_buffer[27];  
  287. //     
  288. //   FILE* fp;  
  289. //   fp = fopen("ms0:/sps_pps.dat", "rb");  
  290. //   fread(sps_pps_buffer, 27, 1, fp);  
  291. //   fclose(fp);  
  292. //   sps_size = 23;  
  293. //   pps_size = 4;  
  294.      
  295.    //———————————————————————————//  
  296.    float curr_ms = 1.0f;  
  297.    u64 last_tick;  
  298.    sceRtcGetCurrentTick(&last_tick);  
  299.    u32 tick_frequency = sceRtcGetTickResolution();  
  300.    int frame_count = 0;  
  301.    sceCtrlReadBufferPositive(&input, 1);  
  302.      
  303.    int pic_num;  
  304.      
  305.    sceDisplayWaitVblankStart();  
  306.    sceDisplaySetFrameBuf(FrameBuffer[frame_index], 512, PSP_DISPLAY_PIXEL_FORMAT_8888, PSP_DISPLAY_SETBUF_IMMEDIATE);  
  307.      
  308. while(!(input.Buttons & PSP_CTRL_TRIANGLE)) {  
  309.      
  310.    float curr_fps = 1.0f / curr_ms;  
  311.    //pspDebugScreenSetXY(0,0);  
  312.    //pspDebugScreenPrintf("fps: %d.%03d \n",(int)curr_fps,(int)((curr_fps-(int)curr_fps) * 1000.0f));  
  313.      
  314.    avc->mpeg_nal.sps_buffer = (&sps_pps_buffer[0]);  
  315.    avc->mpeg_nal.sps_size = sps_size;  
  316.    avc->mpeg_nal.pps_buffer = (&sps_pps_buffer[sps_size]);  
  317.    avc->mpeg_nal.pps_size = pps_size;  
  318.    avc->mpeg_nal.unkown0 = 4;  
  319.    memset(nal_buffer, 0, 1024*1024);  
  320.    mp4ff_read_sample_v2(mp4_handle, 0, frame_count, nal_buffer);  
  321.    avc->mpeg_nal.nal_buffer = nal_buffer;  
  322.    avc->mpeg_nal.nal_size = mp4ff_read_sample_getsize(mp4_handle, 0, frame_count);//size1 ;  
  323.    if ( frame_count == 0 )  
  324.       avc->mpeg_nal.mode = 3;  
  325.    else  
  326.       avc->mpeg_nal.mode = 0;  
  327.    FILE* fp1;  
  328. //   memset(filename,0,1024);  
  329. //   sprintf(filename, "ms0:/mpeg%d_0.dat", frame_count);  
  330. //   fp1 = fopen(filename, "wb");  
  331. //   fwrite(p1, 512, 1, fp1);  
  332. //   fclose(fp1);  
  333.      
  334.    result = sceMpegGetAvcNalAu(&avc->mpeg, &avc->mpeg_nal, avc->mpeg_au);  
  335.    memset(filename,0,1024);  
  336. //   sprintf(filename, "ms0:/au%d_1.dat", frame_count);  
  337. //   fp1 = fopen(filename, "wb");  
  338. //   fwrite(au0, 64, 1, fp1);  
  339. //   fclose(fp1);  
  340. //   pspDebugScreenPrintf(" GetAvcNalAu=0x%08X\n", result);  
  341.      
  342.    result = sceMpegAvcDecode(&avc->mpeg, avc->mpeg_au, 512, 0, &pic_num);  
  343. //   pspDebugScreenPrintf(" AvcDecode=0x%08X,0x%08X\n", result, pic_num);  
  344.    result = sceMpegAvcDecodeDetail2(&avc->mpeg, &avc->mpeg_codec_buffer);  
  345. //   pspDebugScreenPrintf(" AvcDecodeDetail2=0x%08X\n", result);  
  346.      
  347.      
  348.    if ( result == 0 ) {  
  349.       avc->mpeg_yuv_buffer = avc->mpeg_codec_buffer->yuv_buffer;  
  350.       avc->mpeg_info_buffer = avc->mpeg_codec_buffer->info_buffer;  
  351.         
  352.       if ( pic_num > 0 ) {  
  353.          int i;  
  354.          for(i=0;i<pic_num;i++) {  
  355.             int csc_mode = 0;//i % 2;  
  356.             csc->height = avc->mpeg_info_buffer->height >> 4;  
  357.             csc->width = avc->mpeg_info_buffer->width >> 4;  
  358.             csc->mode0 = csc_mode;  
  359.             csc->mode1 = csc_mode;  
  360.             if ( csc_mode == 0 ) {  
  361.                csc->buffer0 = avc->mpeg_yuv_buffer->buffer0 ;  
  362.                csc->buffer1 = avc->mpeg_yuv_buffer->buffer1 ;  
  363.                csc->buffer2 = avc->mpeg_yuv_buffer->buffer2 ;  
  364.                csc->buffer3 = avc->mpeg_yuv_buffer->buffer3 ;  
  365.                csc->buffer4 = avc->mpeg_yuv_buffer->buffer4 ;  
  366.                csc->buffer5 = avc->mpeg_yuv_buffer->buffer5 ;  
  367.                csc->buffer6 = avc->mpeg_yuv_buffer->buffer6 ;  
  368.                csc->buffer7 = avc->mpeg_yuv_buffer->buffer7 ;  
  369.             }  
  370.             else {  
  371.                csc->buffer0 = avc->mpeg_yuv_buffer->buffer2 ;  
  372.                csc->buffer1 = avc->mpeg_yuv_buffer->buffer3 ;  
  373.                csc->buffer2 = avc->mpeg_yuv_buffer->buffer0 ;  
  374.                csc->buffer3 = avc->mpeg_yuv_buffer->buffer1 ;  
  375.                csc->buffer4 = avc->mpeg_yuv_buffer->buffer6 ;  
  376.                csc->buffer5 = avc->mpeg_yuv_buffer->buffer7 ;  
  377.                csc->buffer6 = avc->mpeg_yuv_buffer->buffer4 ;  
  378.                csc->buffer7 = avc->mpeg_yuv_buffer->buffer5 ;  
  379.             }  
  380.               
  381.             result = sceMpegBaseCscAvc(FrameBuffer[frame_index],0,512,csc);  
  382. //            pspDebugScreenPrintf(" BaseCscAvc=0x%08X\n", result);  
  383.             if ( result == 0 ) {  
  384. //               memset(filename,0,1024);  
  385. //               sprintf(filename, "ms0:/RGB%d.%d.dat", frame_count,i);  
  386. //               fp1 = fopen(filename, "wb");  
  387. //               fwrite(RGBBuffer, 4*512*512, 1, fp1);  
  388. //               fclose(fp1);  
  389.                sceDisplayWaitVblankStart();  
  390.                sceDisplaySetFrameBuf(FrameBuffer[frame_index], 512, PSP_DISPLAY_PIXEL_FORMAT_8888, PSP_DISPLAY_SETBUF_IMMEDIATE);  
  391.                frame_index = (frame_index+1) % 2;  
  392.                //sceKernelDelayThread(10000);  
  393.             }  
  394.          }  
  395.       }  
  396.    }  
  397. //   memset(filename,0,1024);  
  398. //   sprintf(filename, "ms0:/mpeg%d.dat", frame_count);  
  399. //   fp1 = fopen(filename, "wb");  
  400. //   fwrite(p1, 512, 1, fp1);  
  401. //   fclose(fp1);  
  402.    ++frame_count;  
  403.    if ( frame_count >= total_samples )  
  404.       break;  
  405.    u64 curr_tick;  
  406.    sceRtcGetCurrentTick(&curr_tick);  
  407.    if ((curr_tick-last_tick) >= tick_frequency)  
  408.    {  
  409.       float time_span = ((int)(curr_tick-last_tick)) / (float)tick_frequency;  
  410.       curr_ms = time_span / frame_count;  
  411.       //frame_count = 0;  
  412.       sceRtcGetCurrentTick(&last_tick);  
  413.    }  
  414.    sceCtrlReadBufferPositive(&input, 1);  
  415. }  
  416. //   fclose(fp);  
  417.   
  418. wait:  
  419.    mp4ff_close(mp4_handle);  
  420.    fclose(mp4_file);  
  421.    pspDebugScreenPrintf("\n");  
  422.    pspDebugScreenPrintf("press triangle to exit…\n");  
  423.    sceCtrlReadBufferPositive(&input, 1);  
  424.    while(!(input.Buttons & PSP_CTRL_TRIANGLE))  
  425.    {  
  426.       sceKernelDelayThread(10000);   // wait 10 milliseconds  
  427.       sceCtrlReadBufferPositive(&input, 1);  
  428.    }  
  429.      
  430.    sceKernelExitGame();  
  431.    return 0;  
  432. }  
  433.   
  434.   
  435. /* Exit callback */  
  436. int exit_callback(int arg1, int arg2, void *common)  
  437. {  
  438.    sceKernelExitGame();  
  439.    return 0;  
  440. }  
  441.   
  442.   
  443. /* Callback thread */  
  444. int CallbackThread(SceSize args, void *argp)  
  445. {  
  446.    int cbid;  
  447.   
  448.    cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);  
  449.    sceKernelRegisterExitCallback(cbid);  
  450.   
  451.    sceKernelSleepThreadCB();  
  452.   
  453.    return 0;  
  454. }  
  455.   
  456.   
  457. /* Sets up the callback thread and returns its thread id */  
  458. int SetupCallbacks(void)  
  459. {  
  460.    int thid = 0;  
  461.   
  462.    thid = sceKernelCreateThread("update_thread", CallbackThread, 0×11, 0xFA0, 0, 0);  
  463.    if(thid >= 0)  
  464.    {  
  465.       sceKernelStartThread(thid, 0, 0);  
  466.    }  
  467.   
  468.    return thid;  
  469. }   

[fw3xx Makefile]

C++ code
  1. TARGET = AvcDecodeTest  
  2. OBJS = main.o mem64.o mpegbase.o  
  3.   
  4. BUILD_PRX = 1  
  5. PSP_FW_VERSION=371  
  6.   
  7. CFLAGS = -G0 -Wall -O2  
  8. CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti  
  9. ASFLAGS = $(CFLAGS)  
  10.   
  11. INCDIR = ./mp4ff/include  
  12. LIBDIR =  .  
  13. LDFLAGS =  
  14. LIBS= -lpsppower -lm -lpsprtc -lpspgu -lpspmpeg -lmp4ff  
  15.   
  16. EXTRA_TARGETS = EBOOT.PBP  
  17. PSP_EBOOT_TITLE = AvcDecode Test  
  18.   
  19. PSPSDK=$(shell psp-config –pspsdk-path)  
  20. include $(PSPSDK)/lib/build.mak   

]]> http://cooleyes.fx-world.org/blog/?feed=rss2&p=7