C++ BMediaRoster::MakeTimeSourceFor方法代码示例

status_t
GameSoundBuffer::StartPlaying()
{
	if (fIsPlaying) 
		return EALREADY;
	
	BMediaRoster* roster = BMediaRoster::Roster();
	BTimeSource* source = roster->MakeTimeSourceFor(fConnection->producer);
	
	// make sure we give the producer enough time to run buffers through
	// the node chain, otherwise it'll start up already late
	bigtime_t latency = 0;
	status_t status = roster->GetLatencyFor(fConnection->producer, &latency);
	if (status == B_OK)
		status = roster->StartNode(fConnection->producer, source->Now() + latency);
	source->Release();
	
	fIsPlaying = true;
	
	return status;
}

//.........这里部分代码省略.........
			ErrorCheck(err, "unable to SetRefFor() to read that sound file!\n");
#else
			r->GetVideoInput(&mConnection.producer);
#endif

			entry_ref logRef;
			::get_ref_for_path("/tmp/node_log", &logRef);

			mLogNode = new LoggingConsumer(logRef);
			err = r->RegisterNode(mLogNode);
			ErrorCheck(err, "unable to register LoggingConsumer node!\n");
			// make sure the Media Roster knows that we're using the node
			r->GetNodeFor(mLogNode->Node().node, &mConnection.consumer);

			// trim down the log's verbosity a touch
			mLogNode->SetEnabled(LOG_HANDLE_EVENT, false);

			// fire off a window with the LoggingConsumer's controls in it
			BParameterWeb* web;
			r->GetParameterWebFor(mConnection.consumer, &web);
			BView* view = BMediaTheme::ViewFor(web);
			BWindow* win = new BWindow(BRect(250, 200, 300, 300), "Controls",
				B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS);
			win->AddChild(view);
			win->ResizeTo(view->Bounds().Width(), view->Bounds().Height());
			win->Show();

			// set the nodes' time sources
			r->GetTimeSource(&mTimeSource);
			r->SetTimeSourceFor(mConnection.consumer.node, mTimeSource.node);
			r->SetTimeSourceFor(mConnection.producer.node, mTimeSource.node);

			// got the nodes; now we find the endpoints of the connection
			media_input logInput;
			media_output soundOutput;
			int32 count;
			err = r->GetFreeOutputsFor(mConnection.producer, &soundOutput, 1, &count);
			ErrorCheck(err, "unable to get a free output from the producer node");
			err = r->GetFreeInputsFor(mConnection.consumer, &logInput, 1, &count);
			ErrorCheck(err, "unable to get a free input to the LoggingConsumer");

			// fill in the rest of the Connection object
			mConnection.source = soundOutput.source;
			mConnection.destination = logInput.destination;

			// got the endpoints; now we connect it!
			media_format format;
#if TEST_WITH_AUDIO
			format.type = B_MEDIA_RAW_AUDIO;			// !!! hmmm.. how to fully wildcard this?
			format.u.raw_audio = media_raw_audio_format::wildcard;
#else
			format.type = B_MEDIA_RAW_VIDEO;			// !!! hmmm.. how to fully wildcard this?
			format.u.raw_video = media_raw_video_format::wildcard;
#endif
			err = r->Connect(mConnection.source, mConnection.destination, &format, &soundOutput, &logInput);
			ErrorCheck(err, "unable to connect nodes");
			mConnection.format = format;

			// for video input, we need to set the downstream latency for record -> playback
			bigtime_t latency;
			r->GetLatencyFor(mConnection.producer, &latency);
			printf("Setting producer run mode latency to %" B_PRIdBIGTIME "\n", latency);
			r->SetProducerRunModeDelay(mConnection.producer, latency + 6000);

			// preroll first, to be a good citizen
			r->PrerollNode(mConnection.consumer);
			r->PrerollNode(mConnection.producer);

			// start the LoggingConsumer and leave it running
			BTimeSource* ts = r->MakeTimeSourceFor(mTimeSource);
			r->StartNode(mConnection.consumer, ts->Now());
			ts->Release();
		}
		break;

	case BUTTON_START:
		mStartButton->SetEnabled(false);
		mStopButton->SetEnabled(true);

		// start the consumer running
		{
			bigtime_t latency;
			BMediaRoster* r = BMediaRoster::Roster();
			BTimeSource* ts = r->MakeTimeSourceFor(mConnection.consumer);
			r->GetLatencyFor(mConnection.producer, &latency);
			r->StartNode(mConnection.producer, ts->Now() + latency);
			ts->Release();
			mIsRunning = true;
		}
		break;

	case BUTTON_STOP:
		StopNodes();
		break;

	default:
		BWindow::MessageReceived(msg);
		break;
	}
}

void
NodeHarnessWin::MessageReceived(BMessage *msg)
{
    status_t err;

    switch (msg->what)
    {
    case BUTTON_CONNECT:
        mIsConnected = true;

        // set the button states appropriately
        mConnectButton->SetEnabled(false);
        mStartButton->SetEnabled(true);

        // set up the node network
        {
            BMediaRoster* r = BMediaRoster::Roster();

            // connect to the mixer
            err = r->GetAudioMixer(&mConnection.consumer);
            ErrorCheck(err, "unable to get the system mixer");

            // fire off a window with the ToneProducer's controls in it
            BParameterWeb* web;
            r->GetParameterWebFor(mConnection.producer, &web);
            BView* view = BMediaTheme::ViewFor(web);
            BWindow* win = new BWindow(BRect(250, 200, 300, 300), "Controls",
                                       B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS);
            win->AddChild(view);
            win->ResizeTo(view->Bounds().Width(), view->Bounds().Height());
            win->Show();

            // set the producer's time source to be the "default" time source, which
            // the Mixer uses too.
            r->GetTimeSource(&mTimeSource);
            r->SetTimeSourceFor(mConnection.producer.node, mTimeSource.node);

            // got the nodes; now we find the endpoints of the connection
            media_input mixerInput;
            media_output soundOutput;
            int32 count = 1;
            err = r->GetFreeOutputsFor(mConnection.producer, &soundOutput, 1, &count);
            ErrorCheck(err, "unable to get a free output from the producer node");
            count = 1;
            err = r->GetFreeInputsFor(mConnection.consumer, &mixerInput, 1, &count);
            ErrorCheck(err, "unable to get a free input to the mixer");

            // got the endpoints; now we connect it!
            media_format format;
            format.type = B_MEDIA_RAW_AUDIO;
            format.u.raw_audio = media_raw_audio_format::wildcard;
            err = r->Connect(soundOutput.source, mixerInput.destination, &format, &soundOutput, &mixerInput);
            ErrorCheck(err, "unable to connect nodes");

            // the inputs and outputs might have been reassigned during the
            // nodes' negotiation of the Connect().  That's why we wait until
            // after Connect() finishes to save their contents.
            mConnection.format = format;
            mConnection.source = soundOutput.source;
            mConnection.destination = mixerInput.destination;

            // Set an appropriate run mode for the producer
            r->SetRunModeNode(mConnection.producer, BMediaNode::B_INCREASE_LATENCY);
        }
        break;

    case BUTTON_START:
        mStartButton->SetEnabled(false);
        mStopButton->SetEnabled(true);

        // start the producer running
        {
            BMediaRoster* r = BMediaRoster::Roster();
            BTimeSource* ts = r->MakeTimeSourceFor(mConnection.producer);
            if (!ts)
            {
                fprintf(stderr, "* ERROR - MakeTimeSourceFor(producer) returned NULL!\n");
                exit(1);
            }

            // make sure we give the producer enough time to run buffers through
            // the node chain, otherwise it'll start up already late
            bigtime_t latency = 0;
            r->GetLatencyFor(mConnection.producer, &latency);
            r->StartNode(mConnection.producer, ts->Now() + latency);
            ts->Release();
            mIsRunning = true;
        }
        break;

    case BUTTON_STOP:
        StopNodes();
        break;

    default:
        BWindow::MessageReceived(msg);
        break;
    }
}