Main : All Content - Java ME & Capuchin

转 [J2ME] MMAPI的Cannot parse this type of AMR异常之讨论

developerworldwatch@kpi-consulting.net — Fri, 20 Nov 2009 11:46:19 GMT

转自旁观者 - 郑昀的博客 http://blog.csdn.net/zhengyun_ustc/archive/2006/04/17/666696.aspx

[J2ME] MMAPI的Cannot parse this type of AMR异常之讨论

郑昀草拟 20060417

[现象]

首先，我们假设遇到这种错误的人们了解如何使用MMAPI，从而排除代码使用不当问题。

那么在播放3gp媒体文件时遇到“java.lang.Exception: Cannot parse this type of AMR”的异常错误，如果怀疑是ffmpeg或者其他转换程序造成的话，那么你可以把Nokia手机自己拍摄的录像传到PC机上，这种文件格式就是3gp的，而且肯定是Nokia自己的手机程序能播放的。

但是，我用mmapi在Nokia S60模拟器（Nokia Developer's Suite 3.0 for J2ME所携带的模拟器）上播放这种Nokia手机生成的3gp文件时依然得到“java.lang.Exception: Cannot parse this type of AMR”错误，没有声音，只有视频。

我用下面的命令行：

Ffmpeg转换命令

ffmpeg -y -i test.mpeg -bitexact -vcodec h263 -b 128 -r 15 -s 176x144 -acodec aac -ac 2 -ar 22500 -ab 24 -f 3gp test.3gp

或者

ffmpeg -y -i test.mpeg -ac 1 -acodec amr_nb -ar 8000 -s 176x144 -b 128 -r 15 test.3gp

转换出来的3gp文件，都只能够在Nokia S60模拟器（Nokia Developer's Suite 3.0 for J2ME所携带的模拟器）上播放视频，但没有声音，也得到了大量的java.lang.Exception: Cannot parse this type of AMR错误提示。

我为什么要怀疑仅仅是S60模拟器的问题呢。因为我把转换好的3gp文件放在我的服务器上，用

简单的播放代码

player = Manager.createPlayer(url);

player.realize();

player.prefetch();

这种代码在Nokia7610真机上运行播放这个远端资源http://218.249.90.118/toodou/test.3gp ，结果正常地播放了，有声音，有图像！

所以说明Nokia 7610真机的MMAPI对于3gp文件中的音频解析是没问题的。出问题的是S60模拟器（Nokia Developer's Suite 3.0 for J2ME所携带的模拟器）

转 [J2ME]手机流媒体之实作[附源码][与RTSP/MMS协议无关]

developerworldwatch@kpi-consulting.net — Fri, 20 Nov 2009 11:42:52 GMT

转自旁观者 - 郑昀的博客http://blog.csdn.net/zhengyun_ustc/archive/2006/03/28/641991.aspx

[J2ME]手机流媒体之实作[附源码][与RTSP/MMS协议无关]

郑昀@ultrapower	产品名称	产品版本
Keyword: JavaME Streaming Audio MMAPI	StreamingDemo	1.0.13

[J2ME]现行环境下手机

实现网络媒体的流畅实时播放

之简单演示

(StreamingDemo)

说明

我的资源：

http://www.cnblogs.com/Files/zhengyun_ustc/StreamingDemo-src-1.0.13.rar

这个1.0.13版本是j2me流媒体播放思路的简单演示软件，并不是对现有的RTSP/MMS流媒体服务器的客户端实现，而是自定义算法下载来保证实时播放，可以在Nokia 7610手机上真实运行。在手机上使用，请在选择连接点时选择“移动梦网”连接点。

如果修改源代码中CommandResources.java中的m_bCMWAPProxy标志使之走CMNET通道，那么能够在Nokia S60的模拟器上运行。

本源代码的大致思路来自于我上次写的三篇讨论稿

J2me流媒体技术实现讨论[1]

J2me流媒体技术实现讨论[2]

J2me流媒体技术实现讨论[3] ，StreamingDemo的代码你可以借鉴，但不得用于商业用途，除非得到我的授权。

手机jar安装包下载：
http://www.cnblogs.com/Files/zhengyun_ustc/StreamingDemo-deployed.rar
可以将这个包中的StreamingDemo.jar传到您的手机上进行安装。
使用时，请选择移动梦网连接点。

如果你想使用劈分好的媒体文件，请从

http://www.cnblogs.com/Files/zhengyun_ustc/changjin.split.rar下载。

1背景、功能

摘要：本章简单描述StreamingDemo的背景、功能。

1.1. 手机上的流媒体

很多人都在j2medev.com上讨论过流媒体的实现方式。国外有一个人提出一种思路，并且号称在Nokia6260[相关数据：诺基亚 6260 Nokia62602.0 (3.0436.0) SymbianOS7.0s Series602.1 ProfileMIDP-2.0 ConfigurationCLDC-1.0]运行了。

当然我们这里说的不是对RTSP/MMS这种主流的流媒体服务器的客户端实现，因为现在中国市场的很多很多手机的Java环境都不支持这两个协议，只有新出的某些手机才内置支持这一功能。

我们这次讲的是，在现有GPRS环境下，在现有的一两千块钱的手机条件下，如何做到流媒体实时播放呢，而且还能做到较为流畅呢？

2006年1月份，我恰巧看到了

就此思路和诸位高手讨论了一下，并且写了三篇讨论稿，有了大致的思路。但一直都没有时间去测试这个思路是否可行。

今天索性抽出了一两个小时，把这个思路写出来放在真实手机/GPRS网络上测试，不敢独享，遂开放代码，希望借此抛砖引玉。

这里给出StreamingDemo的界面，很简单，主要的线程操作和消息处理都在后台：

1.2. 我所谓流媒体的功能

以前我们谈过：

第一步：
声明两个Player，分别由两个独立的线程掌控着；

第二步：
HttpConnection开始向服务器请求该audio文件的第一部分字节，我们定这次读取的字节数为18KB；

第三步：
等第一部分数据到位后，Player A开始realize和prefetch，并开始播放；

第四步：
在Player A播放同时，(18KB的amr数据可以播放10秒钟)，HttpConnection继续请求第二部分数据(假设GPRS每秒钟传输3KB，那么18KB需要传输6秒，算上前后通讯损失的时间，应该不会超过10秒钟)；

第五步：
第二部分数据到位后，假设Player A还没有播放完(这需要调整你的每一部份数据字节数来使得假设成立)，那么将数据喂给Player B让它realize和prefetch；

第六步：
Player A播放完后，得到事件通知，于是让Player B开始播放。

如此往复。

大致的思路就是这样。

这次，我们起了两个线程，一个叫做“Main(主) ”，一个叫做“Secondary(从属)”，他们都掌握着一个Player，同样一个是Main Player，一个是Secondary Player。这两个Player的操作实际上都被Audio.java类完全封装好了。线程里面仅仅是调用

Audio.prefetchSound(m_form,

m_isInputMusic,

m_Sequence);

啦，

Audio.playSound(m_Sequence);

啦，这样就可以把媒体资源预先运算以及播放了。

同时，还必须用到PlayerListener接口，来得到播放器的各种事件通知，我们需要得知每一个播放器的播放结束消息，以便作出下一步选择：是让从属线程开始播放呢，还是让主线程开始播放呢。

PlayerListener的播放结束消息(PlayerListener.END_OF_MEDIA)的处理中，我们还必须用到MVC模式中的Controller，它是代码中的GUIController.java，它负责处理几个消息：

l EventID.EVENT_MAIN_DownloadCompleted

l EventID.EVENT_Main_BeginToPlay

l EventID.EVENT_SECONDARY_BeginToPlay

怎么综合使用这些消息和事件呢？

比如说，当主线程的媒体文件下载完毕后，就应该通知GUIController让从属线程也开始下载并加载媒体文件。

当主线程的媒体文件播放完毕了，这时候照理说从属线程的Player也已经预先加载好了下一个要播放的媒体文件(如果不行的话就应该调整媒体文件的大小了以使得下载时间和播放时间差不多)，就应该在

public void playerUpdate(Player player, String event, Object data)

的函数处理中，让Secondary Player播放了。

这次我们直接将媒体文件用讨论稿中谈及的ffmpeg自动切分的办法，已经辟成11小段的AMR文件了，每一个AMR文件都可以独立播放，连起来就是一首完整的《大长今》乐曲。

PlayerA和PlayerB只是周而复始的下载、预运算、播放他们罢了。只不过掌控着Player的两个线程和主控制器，会选择时机来让这些操作次第展开。

上面所说的逻辑，可以用下图表示：

2 使用感受

摘要：本章简单描述StreamingDemo在真实GPRS环境下的使用感受。

2.1. Nokia7610手机上的设置

如果你真的要在手机上用到这种功能，那么请申请开通你的GPRS包月套餐，那样20块钱就可以使用50MB流量的GPRS了。

如果你的手机是Nokia的S60系列手机，建议用Nokia程序管理器设置这个应用配置一个参数：在连接网络时第一次询问。否则你会屡屡被网络连接警告框打断的。

2.2. Nokia7610手机上的使用感受

这种流媒体的播放，还是取决于使用时GPRS网络的好坏。

我在晚上19点使用了一下，感觉比较流畅，甚至超乎我的预期，不认真听，甚至感觉不到在哪里停顿的。

但是在晚上20点又用了一下，就有点拖拖拉拉的，延迟较为明显。

可见现行的GPRS网络环境还是容易出现拥挤的。

3 开源版权声明

由于这个手机流媒体简单演示的思路和代码来自于郑昀以前的讨论稿，今为了促进J2ME多媒体应用发展，决定遵照GPL协议的大意开放源代码，您可以自由传播和修改，在遵照下面的约束条件的前提下：

条件1

条件2

你可以修改 手机流媒体简单演示 程序的一个或几个副本或程序的任何部分，以此形成基于程序的作品。只要你同时满足下面的所有条件，你就可以按前面第一款的要求复制和发布这一经过修改的程序或作品。

a）

你必须在修改的文件中附有明确的说明：你修改了这一文件及具体的修改日期。

b）

你必须使你发布或出版的作品（它包含程序的全部或一部分，或包含由程序的全部或部分衍生的作品）允许第三方作为整体按许可证条款免费使用。

c）

这样，您就可以自由使用并传播本源代码，当然请您原封不动地保留创建者zhengyun_ustc(郑昀)的作者信息。

Java ME中如何录制比支持视频格式更小的视频？

developerworldwatch@kpi-consulting.net — Thu, 19 Nov 2009 07:03:39 GMT

很强大。这些我都没研究过。搞好了写个总结上来撒。

Java Verified 手册

developerworldwatch@kpi-consulting.net — Tue, 17 Nov 2009 09:30:37 GMT

本手册将逐步指导您实现，如何通过 Java Verified 提交门户网站提交应用软件进行认证，并简要介绍提交门户网站能为已提交的软件提供哪些服务。

它将带您通过认证流程涉及的所有步骤，包括从获取 Publisher ID 到最终在线提交应用软件进行测试与签名。

目录
1. 本手册的用途
2. 什么是 Java Verified 提交门户网站？
3. 什么是 Publisher ID？我该如何使用它？
4. 我该如何注册使用提交门户网站？
5. 在提交应用软件之前我需要做些什么？
6. 我该如何将应用软件提交到门户网站？
7. 我该如何提交应用软件进行研发签名？
8. 我该如何提交应用软件进行测试与签名？
9. 我该如何在门户网站上找到提交的内容？
附录 A: 签署多个 JAD / JAR 文件对的脚本示例
附录 B: 常见问题解答

关于如何在索尼爱立信手机上进行 Java 签名和 Java 的权限设置，请阅读下面的文章>>

索尼爱立信手机 Java ME 签名指南

索尼爱立信手机的 Java ME 的权限设置

http://www.javaverified.com

CAPUCHIN中在FLASH CS3中可以实现ACCELEROMETER感应游戏吗？

developerworldwatch@kpi-consulting.net — Mon, 16 Nov 2009 14:51:03 GMT

这个可见参见相关文档：

数据传输接口以及相应的类和功能指令应当在真实的Flash Lite和Java应用程序开始开发前就定义完毕。

存在两种类型的数据传输方法：

• DataRequest. 由MIDlet处理一个来自Flash Lite应用程序的数据请求，数据回馈不同步。为处理这个请求，MIDlet可以使用手机Java平台上可用的任何JSRs。

• ExtendedEvent. Flash Lite内容接收由MIDlet激发的事件。

具体的用法得看例子学习了，capuchin在一定程度上对j2me有很大的帮助，但是这个刚推出业不久，希望能在这多多交流

面向 Flash Lite 和 Java 开发者的 Capuchin 计划入门指南适用于索尼爱立信手机 (1.57 MB)

关于java进行flash播放的问题

developerworldwatch@kpi-consulting.net — Mon, 16 Nov 2009 14:29:47 GMT

查了一下相关资料，没有看到有相关的支持的说明。目前只能在支持cauchin的手机才能支持

关于索爱手机读取生日字段的问题

developerworldwatch@kpi-consulting.net — Sat, 14 Nov 2009 14:25:09 GMT

1970年是unix系统发布的时间，很多系统都是拿那个时间开始计算的，比如linux,它的内核时间记寻的是与1970年相差的时间，java得到当前时间也是如此，如果系统有问题，你在存时试用自己的算法去存，读的时候再进行还原，看成不成

Java线程的同步

developerworldwatch@kpi-consulting.net — Wed, 11 Nov 2009 01:38:50 GMT

在J2ME开发中，线程是一个需要非常重视的问题，下面是一段关于线程的文章。我认为对打好线程基本很有帮助。

zz http://www.j2medev.com/Article/ShowArticle.asp?ArticleID=5478

一、同步问题提出

线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。

例如：两个线程ThreadA、ThreadB都操作同一个对象Foo对象，并修改Foo对象上的数据。

public class Foo {
    private int x = 100;

    public int getX() {
        return x;
    }

    public int fix(int y) {
        x = x - y;
        return x;
    }
}

public class MyRunnable implements Runnable {
    private Foo foo = new Foo();

    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread ta = new Thread(r, "Thread-A");
        Thread tb = new Thread(r, "Thread-B");
        ta.start();
        tb.start();
    }

    public void run() {
        for (int i = 0; i < 3; i++) {
            this.fix(30);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " : 当前foo对象的x值= " + foo.getX());
        }
    }

    public int fix(int y) {
        return foo.fix(y);
    }
}

运行结果：

Thread-A : 当前foo对象的x值= 40
Thread-B : 当前foo对象的x值= 40
Thread-B : 当前foo对象的x值= -20
Thread-A : 当前foo对象的x值= -50
Thread-A : 当前foo对象的x值= -80
Thread-B : 当前foo对象的x值= -80

Process finished with exit code 0

从结果发现，这样的输出值明显是不合理的。原因是两个线程不加控制的访问Foo对象并修改其数据所致。

如果要保持结果的合理性，只需要达到一个目的，就是将对Foo的访问加以限制，每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。

在具体的Java代码中需要完成一下两个操作：

把竞争访问的资源类Foo变量x标识为private；

同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。

二、同步和锁定

1、锁的原理

Java中每个对象都有一个内置锁

当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。

当程序运行到synchronized同步方法或代码块时才该对象锁才起作用。

一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。

释放锁是指持锁线程退出了synchronized同步方法或代码块。

关于锁和同步，有一下几个要点：

1）、只能同步方法，而不能同步变量和类；

2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？

3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。

4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。

5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。

6）、线程睡眠时，它所持的任何锁都不会释放。

7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。

8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。

9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。例如：

    public int fix(int y) {
        synchronized (this) {
            x = x - y;
        }
        return x;
    }

当然，同步方法也可以改写为非同步方法，但功能完全一样的，例如：

    public synchronized int getX() {
        return x++;
    }

与

    public int getX() {
        synchronized (this) {
            return x;
        }
    }

效果是完全一样的。

三、静态方法同步

要同步静态方法，需要一个用于整个类对象的锁，这个对象是就是这个类（XXX.class)。

例如：

public static synchronized int setName(String name){

Xxx.name = name;

}

等价于
public static int setName(String name){
      synchronized(Xxx.class){
            Xxx.name = name;
      }
}

四、如果线程不能不能获得锁会怎么样

如果线程试图进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞。实质上，线程进入该对象的的一种池中，必须在哪里等待，直到其锁被释放，该线程再次变为可运行或运行为止。

当考虑阻塞时，一定要注意哪个对象正被用于锁定：

1、调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。

2、调用同一个类中的静态同步方法的线程将彼此阻塞，它们都是锁定在相同的Class对象上。

3、静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。

4、对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁定的线程将永远不会彼此阻塞。

五、何时需要同步

在多个线程同时访问互斥（可交换）数据时，应该同步以保护数据，确保两个线程不会同时修改更改它。

对于非静态字段中可更改的数据，通常使用非静态方法访问。

对于静态字段中可更改的数据，通常使用静态方法访问。

如果需要在非静态方法中使用静态字段，或者在静态字段中调用非静态方法，问题将变得非常复杂。已经超出SJCP考试范围了。

六、线程安全类

当一个类已经很好的同步以保护它的数据时，这个类就称为“线程安全的”。

即使是线程安全类，也应该特别小心，因为操作的线程是间仍然不一定安全。

举个形象的例子，比如一个集合是线程安全的，有两个线程在操作同一个集合对象，当第一个线程查询集合非空后，删除集合中所有元素的时候。第二个线程也来执行与第一个线程相同的操作，也许在第一个线程查询后，第二个线程也查询出集合非空，但是当第一个执行清除后，第二个再执行删除显然是不对的，因为此时集合已经为空了。

看个代码：

public class NameList {
    private List nameList = Collections.synchronizedList(new LinkedList());

    public void add(String name) {
        nameList.add(name);
    }

    public String removeFirst() {
        if (nameList.size() > 0) {
            return (String) nameList.remove(0);
        } else {
            return null;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        final NameList nl = new NameList();
        nl.add("aaa");
        class NameDropper extends Thread{
            public void run(){
                String name = nl.removeFirst();
                System.out.println(name);
            }
        }

        Thread t1 = new NameDropper();
        Thread t2 = new NameDropper();
        t1.start();
        t2.start();
    }
}

虽然集合对象

private List nameList = Collections.synchronizedList(new LinkedList());
是同步的，但是程序还不是线程安全的。

出现这种事件的原因是，上例中一个线程操作列表过程中无法阻止另外一个线程对列表的其他操作。

解决上面问题的办法是，在操作集合对象的NameList上面做一个同步。改写后的代码如下：

public class NameList {
    private List nameList = Collections.synchronizedList(new LinkedList());

    public synchronized void add(String name) {
        nameList.add(name);
    }

    public synchronized String removeFirst() {
        if (nameList.size() > 0) {
            return (String) nameList.remove(0);
        } else {
            return null;
        }
    }
}

这样，当一个线程访问其中一个同步方法时，其他线程只有等待。

七、线程死锁

死锁对Java程序来说，是很复杂的，也很难发现问题。当两个线程被阻塞，每个线程在等待另一个线程时就发生死锁。

还是看一个比较直观的死锁例子：

public class DeadlockRisk {
    private static class Resource {
        public int value;
    }

    private Resource resourceA = new Resource();
    private Resource resourceB = new Resource();

    public int read() {
        synchronized (resourceA) {
            synchronized (resourceB) {
                return resourceB.value + resourceA.value;
            }
        }
    }

    public void write(int a, int b) {
        synchronized (resourceB) {
            synchronized (resourceA) {
                resourceA.value = a;
                resourceB.value = b;
            }
        }
    }
}

假设read()方法由一个线程启动，write()方法由另外一个线程启动。读线程将拥有resourceA锁，写线程将拥有resourceB锁，两者都坚持等待的话就出现死锁。

实际上，上面这个例子发生死锁的概率很小。因为在代码内的某个点，CPU必须从读线程切换到写线程，所以，死锁基本上不能发生。

但是，无论代码中发生死锁的概率有多小，一旦发生死锁，程序就死掉。有一些设计方法能帮助避免死锁，包括始终按照预定义的顺序获取锁这一策略。已经超出SCJP的考试范围。

八、线程同步小结

1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。

2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法。

3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。

4、对于同步，要时刻清醒在哪个对象上同步，这是关键。

5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。

6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。

7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。

J2ME怎么压缩图片？

developerworldwatch@kpi-consulting.net — Thu, 05 Nov 2009 05:34:04 GMT

嗯，这样做确实不错。不过总是感觉用户体验上有点差。另外现在手机的照相机越来越强大，图片也越来越大，不压缩直接传，一个很大的图片很容易传不上去

索爱SDK2.5.0.6仍未支持运行Capuchin计划？

developerworldwatch@kpi-consulting.net — Wed, 04 Nov 2009 06:05:25 GMT

客气，相互交流而已，欢迎多来发帖