Actionscript 3 将网络摄像头中的h.264录制为flash中的f4v

使用FlashMediaServer，我有一个预先制作的应用程序，它可以从网络摄像头和麦克风录制视频，并将其作为FLV文件发布到FMS服务器

这很好，但我现在需要将录制到iOS设备上的视频流式传输。我已经让FMS工作，它可以将hls记录/sample.f4v.m3u8文件流式传输到iOS/quicktime设备

我在网上阅读了一些教程，并将发布（文件名，“记录”）更改为发布（“mp4:“+filename+”.f4v”，记录）

它记录并存储FMS服务器上的文件（我在那里看到它，带有我给它的文件名和.f4v文件），它有内容。当我开始播放时（通过quicktime或safari），我看到了视频的长度（4秒作为测试），但没有视频。跟踪栏不移动，等待图标等待

FMS版本4.5和Flash 11.3安装在我的Mac上。（CentOS 5.8服务器）

我一定错过了什么

package com
{
import fl.controls.ProgressBar;
import fl.controls.ProgressBarMode;
import flash.display.MovieClip;
import flash.events.Event;
import com.NetConnector
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.media.Camera;
import flash.media.Microphone;
import flash.media.Video;
import flash.net.navigateToURL;
import flash.net.NetConnection;
import flash.net.NetStream;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import flash.net.URLRequestMethod;
import flash.net.URLVariables;
import flash.text.TextField;
import flash.utils.setTimeout;
import flash.utils.Timer;
import flash.media.H264Level;
import flash.media.H264Profile;
import flash.media.H264VideoStreamSettings;
/**
 * ...
 * @author Alexander (flash2you) < >
 */
public class Recorder extends MovieClip
{
    private var dataHolder:DataHolder = DataHolder.getInstance()

    public var layer:MovieClip
    public var activityLevel_pb:ProgressBar
    public var aguja:MovieClip
    public var aguja2:MovieClip
    public var publishButton:MovieClip
    public var timer_txt:TextField
    public var recordStatus:MovieClip
    public var recordBtn:MovieClip

    private var netStream:NetStream
    private var microphone:Microphone = Microphone.getMicrophone()
    private var camera:Camera = Camera.getCamera()
    public var  video:Video

    private var timer:Timer = new Timer(100)
    private var clockTimer:Timer = new Timer(1000)

    public var published:Boolean = false

    private var isRecording:Boolean = false

    private var minutero = 0;
    private var crono = 0;
    private var records = 0;


    public var settings_mc:MovieClip
    public static var recorder:Recorder
    public var settings_icon:MovieClip

    private var limitTimer:Timer
    public function Recorder()
    {
        Recorder.recorder = this;

        timer.addEventListener(TimerEvent.TIMER, on$timer)
        clockTimer.addEventListener(TimerEvent.TIMER, on$clockTimer)
        //visible = false


        recordBtn.buttonMode = true
        recordBtn.addEventListener(MouseEvent.CLICK , recordBtn$click)
        recordBtn.addEventListener(MouseEvent.MOUSE_OVER, recordBtn$over)
        recordBtn.addEventListener(MouseEvent.MOUSE_OUT, recordBtn$out)

        addEventListener(Event.ADDED_TO_STAGE, onAddedToStage)


        limitTimer = new Timer(dataHolder.timelimit * 1000);
        limitTimer.addEventListener(TimerEvent.TIMER, onLimitTimerHandler)
    }

    private function onLimitTimerHandler(e:TimerEvent):void
    {
         stopPublish()
    }
    /*
     *  when we comes to second frame
     * */
    private function onAddedToStage(e:Event):void
    {
        removeEventListener(Event.ADDED_TO_STAGE, onAddedToStage);

        init()
    }
    /*
     *   function for set up camera from settings module
     * */
    public function setCamera(_camera:Camera) {
        camera = _camera
        addCameraSettings()

        video.attachCamera(camera)

        if (netStream){
            netStream.attachCamera(camera)
        }
    }

    public function setMicrophone(mic:Microphone) {
        microphone = mic;

        if (netStream){
            netStream.attachAudio(microphone)
        }

        addMicSettings()
    }

    private function addMicSettings() {
        microphone.setUseEchoSuppression(true);
        microphone.setSilenceLevel(1)
    }

    private function addCameraSettings():void
    {
        camera.setQuality(90000, 90);
        camera.setMode(320, 240, 30, true);
        camera.setKeyFrameInterval(15);
        //camera.setMode(dataHolder.cameraWidth, dataHolder.cameraHeight, dataHolder.cameraFPS)
        //camera.setQuality(0, dataHolder.cameraQuality)
    }

    public function init() {
        startConnect()
    }
    /*
     *  main function for connection
     * */
    private function startConnect() {
        visible = true

        timer_txt.htmlText = "<b>00:00</b>";

        initCamera()
        initMicropone()
        var nc:NetConnection = new NetConnection()
        nc.connect(null)
        netStream = new NetStream(nc)
        netStream.attachAudio(microphone)

        video.attachCamera(camera)
        layer.visible = false


        publishButton.gotoAndStop(1);


        activityLevel_pb.mode = ProgressBarMode.MANUAL;

        recordStatus.gotoAndStop("noRecord")

        timer.start()


        connection.addEventListener(NetConnector.CONNECTED, connectionComplete)
        connection.startConnection()
    }

    public function get connection():NetConnector {
        return dataHolder.connection
    }

    private function on$timer(e:TimerEvent) {
        activityLevel_pb.setProgress(microphone.activityLevel, 100)
    }
    /*
     *  when connection to your stream server done
     * */
    private function connectionComplete(e:Event = null) {
        netStream = new NetStream(connection)
        netStream.attachAudio(microphone)
        netStream.attachCamera(camera)
    }

    /*
     *   add 0 if less then 10secs
     * */
    private function addLeading(nbr) {
        if (nbr<10) {
            return ("0"+Math.floor(nbr));
        } else {
            return (Math.floor(nbr).toString());
        }
    }

    /*
     *   update visible clock, rotate arrows
     * */
    private function updateTimer() {
        timer_txt.htmlText = "<b>"+addLeading(crono/60)+":"+addLeading(crono%60)+"</b>";
        aguja.rotation = aguja.rotation+6;
        if (addLeading(crono/60)>minutero) {
            aguja2.rotation = aguja2.rotation+6;
            ++minutero;
        }
        // end if
        ++crono;
    }

    private function on$clockTimer(e:TimerEvent):void
    {
        updateTimer()
    }
    private function startClockTimer() {
        clockTimer.start()
    }

    /*
     *  update graphics and start recording
     * */
    private function recordBtn$click(e:MouseEvent):void
    {
        if (!isRecording) {
            startRecording()
            recordStatus.gotoAndStop("record")
            recordBtn.visible = false
        }
    }

    private function recordBtn$over(e:MouseEvent):void
    {
        if (!isRecording) {
            this.gotoAndPlay(65);
        }
    }
    private function recordBtn$out(e:MouseEvent):void
    {
        if (!isRecording) {
            this.gotoAndPlay(61);
        }
    }

    private function startRecording() {
        if (connection.connected){

            var h264Settings:H264VideoStreamSettings = new H264VideoStreamSettings();
            h264Settings.setProfileLevel(H264Profile.BASELINE, H264Level.LEVEL_3_1);


            netStream.videoStreamSettings = h264Settings;

            netStream.publish("mp4:" + dataHolder.filename + ".f4v", "record");

            var metaData:Object = new Object();
            metaData.codec = netStream.videoStreamSettings.codec;
            metaData.profile =  h264Settings.profile;
            metaData.level = h264Settings.level;
            metaData.fps = camera.fps;
            metaData.bandwith = camera.bandwidth;
            metaData.height = camera.height;
            metaData.width = camera.width;
            metaData.keyFrameInterval = camera.keyFrameInterval;
            metaData.copyright = "company";
            netStream.send("@setDataFrame", "onMetaData", metaData);

        }

        isRecording = true
        startClockTimer()

        publishButton.gotoAndPlay(2)
        publishButton.buttonMode = true
        publishButton.addEventListener(MouseEvent.CLICK, publishButton$click);


        limitTimer.start()
    }

    /*
     *  redirect to finishURL that was passed via flashvars
     * */
    private function publishButton$click(e:MouseEvent):void
    {
        stopPublish()

        var request:URLRequest = new URLRequest(dataHolder.finishURL)
        navigateToURL(request, "_self")
    }

    private function stopPublish():void
    {
        netStream.close();
        connection.close();

        limitTimer.stop();
        clockTimer.stop();

        isRecording = false

        recordStatus.gotoAndStop("recordEnd")

        updateTimer();
    }
    /*
     *  init microphone
     * */
    private function initMicropone():void
    {
        microphone = Microphone.getMicrophone()
        addMicSettings()
    }
    /*
     *  init camera
     * */
    private function initCamera():void
    {
        camera = Camera.getCamera()
        addCameraSettings()
    }
}
}

package-com
{
导入fl.controls.ProgressBar；
导入fl.controls.ProgressBarMode；
导入flash.display.MovieClip；
导入flash.events.Event；
导入com.NetConnector
导入flash.events.MouseEvent；
导入flash.events.TimerEvent；
导入flash.media.Camera；
导入flash.media.microscope；
导入flash.media.Video；
导入flash.net.navigateToURL；
导入flash.net.NetConnection；
导入flash.net.NetStream；
导入flash.net.urloader；
导入flash.net.URLLoaderDataFormat；
导入flash.net.URLRequest；
导入flash.net.URLRequestMethod；
导入flash.net.url变量；
导入flash.text.TextField；
导入flash.utils.setTimeout；
导入flash.utils.Timer；
导入flash.media.h264级别；
导入flash.media.h264配置文件；
导入flash.media.h264视频流设置；
/**
* ...
*@作者亚历山大（flash2you）<>
*/
公共类录音机扩展MovieClip
{
私有变量dataHolder:dataHolder=dataHolder.getInstance（）
公共变量层：MovieClip
公共var activityLevel_pb:ProgressBar
公共var aguja:MovieClip
公共var aguja2:MovieClip
公共var publishButton:MovieClip
公共变量计时器\u txt:TextField
公共var记录状态：MovieClip
公共var记录BTN:MovieClip
私有变量netStream:netStream
专用var麦克风：麦克风=麦克风。GetMirror（）
private-var-camera:camera=camera.getCamera（）
公共视频：视频
专用变量计时器：计时器=新计时器（100）
专用var时钟计时器：计时器=新计时器（1000）
公共变量已发布：布尔值=false
私有变量isRecording:Boolean=false
私有变量minutero=0；
私有变量crono=0；
私有var记录=0；
公共var设置\u mc:MovieClip
公共静态var记录器：记录器
公共变量设置\u图标：MovieClip
专用变量限制计时器：计时器
公共功能记录器（）
{
Recorder.Recorder=这个；
timer.addEventListener（TimerEvent.timer，在$timer上）
clockTimer.addEventListener（TimerEvent.TIMER，在$clockTimer上）
//可见=假
recordBtn.buttonMode=true
recordBtn.addEventListener（MouseEvent.CLICK，recordBtn$CLICK）
recordBtn.addEventListener（MouseEvent.MOUSE_OVER，recordBtn$OVER）
recordBtn.addEventListener（MouseEvent.MOUSE_OUT，recordBtn$OUT）
addEventListener（Event.ADDED_至_阶段，OnAddedStatage）
limitTimer=新计时器（dataHolder.timelimit*1000）；
limitTimer.addEventListener（TimerEvent.TIMER，onLimitTimerHandler）
}
私有函数onLimitTimerHandler（e:TimerEvent）：void
{
停止发表
}
/*
*当我们进入第二帧时
* */
AddedStatage上的私有函数（e:事件）：void
{
移除EventListener（Event.ADDED_至_阶段，OnAddedStatage）；
init（）
}
/*
*从设置模块设置摄像头的功能
* */
公共功能设置摄像头（_摄像头：摄像头）{
照相机
addCameraSettings（）
视频。附加摄像头（摄像头）
if（netStream）{
netStream.attachCamera（摄像头）
}
}
公共功能设置麦克风（麦克风：麦克风）{
麦克风=麦克风；
if（netStream）{
netStream.attachAudio（麦克风）
}
addMicSettings（）
}
私有函数addMicSettings（）{
麦克风。设置回声抑制（真）；
麦克风设置音量（1）
}
私有函数addCameraSettings（）：void
{
摄像机设置质量（90000,90）；
摄像头设置模式（320、240、30、真）；
摄像头。设置关键帧间隔（15）；
//camera.setMode（dataHolder.cameraWidth、dataHolder.cameraHeight、dataHolder.cameraFPS）
//camera.setQuality（0，数据保持器.cameraQuality）
}
公共函数init（）{
startConnect（）
}
/*
*连接的主要功能
* */
专用函数startConnect（）{
可见=真
定时器_txt.htmlText=“00:00”；
initCamera（）
微孔（）
var nc:NetConnection=newnetconnection（）
nc.connect（空）
netStream=新netStream（nc）
netStream.attachAudio（麦克风）
视频。附加摄像头（摄像头）
layer.visible=false
publishButton.gotoAndStop（1）；
activityLevel_pb.mode=ProgressBarMode.MANUAL；
recordStatus.gotoAndStop（“noRecord”）
timer.start（）
connection.addEventListener（NetConnector.CONNECTED，connectionComplete）
connection.startConnection（）的
}
公用函数get connection（）：NetConnector{
返回dataHolder.connection
}
$timer上的私有函数（e:TimerEvent）{
activityLevel_pb.setProgress（麦克风activityLevel，100）
}
/*
*连接到流服务器完成时
* */
私有函数连接完成（e:Event=null）{
netStream=新netStream（连接）
netStream.attachAudio（麦克风）
netStream.attachCamera（摄像头）
}
/*
*如果小于10秒，则添加0
* */
私有的