C++ PacketStream::start方法代码示例

    // ---------------------------------------------------------------------
    // Audio CaptureRecorder Test
    //
    void runAVInputReaderRecorderTest()
    {
        PacketStream stream;

        // Create the Encoder Options
        av::EncoderOptions options;
        options.ofile = "audio_test.mp4";
        options.duration = 5; //time(0) +
        options.oformat = av::Format("AAC", "aac",
            av::AudioCodec("AAC", "aac", 2, 44100, 96000, "fltp"));
            //av::AudioCodec("MP3", "libmp3lame", 2, 44100, 128000, "s16p"));

        // Attach the Audio Capture
        av::AVInputReader::Ptr reader(new av::AVInputReader());
        reader->openAudioDevice(0,
            options.oformat.audio.channels,
            options.oformat.audio.sampleRate);
        reader->getEncoderFormat(options.iformat);

        // Attach the Audio Capture
        stream.attachSource<av::AVInputReader>(reader, true);

        // Attach the Audio Encoder
        auto encoder = new av::AVPacketEncoder(options);
        encoder->initialize();
        stream.attach(encoder, 5, true);

        stream.start();
        scy::pause();
        stream.stop();
    }

    // ---------------------------------------------------------------------
    // Audio CaptureRecorder Test
    //
    void runAudioStreamRecorderTest()
    {
        PacketStream stream;

        // Create the Encoder Options
        av::EncoderOptions options;
        options.ofile = "audio_test.mp3";
        //options.stopAt = time(0) + 5;
        options.oformat = av::Format("MP3", "mp3",
            av::AudioCodec("MP3", "libmp3lame", 2, 44100, 128000, "s16p"));

        // Create the Audio Capture
        av::Device dev;
        auto& media = av::MediaFactory::instance();
        media.devices().getDefaultAudioInputDevice(dev);
        InfoL << "Default audio capture " << dev.id << endl;
        av::AudioCapture::Ptr audioCapture = media.createAudioCapture(0, //dev.id
            options.oformat.audio.channels,
            options.oformat.audio.sampleRate);
        audioCapture->getEncoderFormat(options.iformat);

        // Attach the Audio Capture
        stream.attachSource<av::AudioCapture>(audioCapture, true);

        // Attach the Audio Encoder
        //auto encoder = new av::AVPacketEncoder(options);
        //encoder->initialize();
        //stream.attach(encoder, 5, true);

        //CaptureRecorder enc(audioCapture, options);

        stream.start();
        scy::pause();
        stream.stop();
    }

int main(int argc, char** argv)
{
    Logger::instance().add(new ConsoleChannel("debug", Level::Trace)); // Debug
    {
        // Create a PacketStream to pass packets
        // from device captures to the encoder
        PacketStream stream;

        av::EncoderOptions options;
        options.ofile = OUTPUT_FILENAME;
        options.oformat = OUTPUT_FORMAT;
        options.iformat.audio.enabled = false; // enabled if available
        options.iformat.video.enabled = false; // enabled if available

        // Create a device manager instance to enumerate system devices
        av::Device device;
        av::DeviceManager devman;

        // Create and attach the default video capture
        av::VideoCapture video;
        if (devman.getDefaultCamera(device)) {
            LInfo("Using video device: ", device.name)
            video.openVideo(device.id, { 640, 480 });
            video.getEncoderFormat(options.iformat);
            stream.attachSource(&video, false, true);
        }

        // Create and attach the default audio capture
        av::AudioCapture audio;
        if (devman.getDefaultMicrophone(device)) {
            LInfo("Using audio device: ", device.name)
            audio.openAudio(device.id, { 2, 44100 });
            audio.getEncoderFormat(options.iformat);
            stream.attachSource(&audio, false, true);
        }

        // Create and attach the multiplex encoder
        av::MultiplexPacketEncoder encoder(options);
        encoder.init();
        stream.attach(&encoder, 5, false);

        // Start the stream
        stream.start();

        // Keep recording until Ctrl-C is pressed
        LInfo("Recording video: ", OUTPUT_FILENAME)
        waitForShutdown([](void* opaque) {
            reinterpret_cast<PacketStream*>(opaque)->stop();
        }, &stream);
    }

    // Logger::destroy();
    return 0;
}

    void testVideoCaptureStream()
    {
        DebugL << "Starting" << endl;

        av::VideoCapture::Ptr capture = MediaFactory::instance().createVideoCapture(0);
        {
            PacketStream stream;
            stream.emitter += packetDelegate(this, &Tests::onVideoCaptureStreamFrame);
            stream.attachSource<av::VideoCapture>(capture, true);
            stream.start();

            std::puts("Press any key to continue...");
            std::getchar();
        }

        assert(capture->emitter.ndelegates() == 0);

        DebugL << "Complete" << endl;
    }