src/starboard/raspi/shared/open_max/open_max_component.cc - cobalt - Git at Google

 // Copyright 2016 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "starboard/raspi/shared/open_max/open_max_component.h"

 #include <algorithm>

 #include "starboard/configuration.h"
 #include "starboard/once.h"
 #include "starboard/thread.h"

 namespace starboard {
 namespace raspi {
 namespace shared {
 namespace open_max {

 namespace {

 const int kInvalidPort = -1;

 OMX_INDEXTYPE kPortTypes[] = {OMX_IndexParamAudioInit, OMX_IndexParamVideoInit,
                               OMX_IndexParamImageInit, OMX_IndexParamOtherInit};

 SbOnceControl s_open_max_initialization_once = SB_ONCE_INITIALIZER;

 void DoInitializeOpenMax() {
   OMX_ERRORTYPE error = OMX_Init();
   SB_DCHECK(error == OMX_ErrorNone);
 }

 void InitializeOpenMax() {
   bool initialized =
       SbOnce(&s_open_max_initialization_once, DoInitializeOpenMax);
   SB_DCHECK(initialized);
 }

 }  // namespace

 OpenMaxComponent::OpenMaxComponent(const char* name)
     : condition_variable_(mutex_),
       handle_(NULL),
       input_port_(kInvalidPort),
       output_port_(kInvalidPort),
       output_setting_changed_(false),
       output_port_enabled_(false) {
   InitializeOpenMax();

   OMX_CALLBACKTYPE callbacks;
   callbacks.EventHandler = OpenMaxComponent::EventHandler;
   callbacks.EmptyBufferDone = OpenMaxComponent::EmptyBufferDone;
   callbacks.FillBufferDone = OpenMaxComponent::FillBufferDone;

   OMX_ERRORTYPE error =
       OMX_GetHandle(&handle_, const_cast<char*>(name), this, &callbacks);
   SB_DCHECK(error == OMX_ErrorNone);

   for (size_t i = 0; i < SB_ARRAY_SIZE(kPortTypes); ++i) {
     OMX_PORT_PARAM_TYPE port;
     port.nSize = sizeof(OMX_PORT_PARAM_TYPE);
     port.nVersion.nVersion = OMX_VERSION;

     error = OMX_GetParameter(handle_, kPortTypes[i], &port);
     if (error == OMX_ErrorNone && port.nPorts == 2) {
       input_port_ = port.nStartPortNumber;
       output_port_ = input_port_ + 1;
       SendCommandAndWaitForCompletion(OMX_CommandPortDisable, input_port_);
       SendCommandAndWaitForCompletion(OMX_CommandPortDisable, output_port_);
       break;
     }
   }
   SB_CHECK(input_port_ != kInvalidPort);
   SB_CHECK(output_port_ != kInvalidPort);
   SB_DLOG(INFO) << "Opened \"" << name << "\" with port " << input_port_
                 << " and " << output_port_;

   SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateIdle);
 }

 OpenMaxComponent::~OpenMaxComponent() {
   if (!handle_) {
     return;
   }
   SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateIdle);

   SendCommandAndWaitForCompletion(OMX_CommandFlush, input_port_);
   SendCommandAndWaitForCompletion(OMX_CommandFlush, output_port_);

   SendCommand(OMX_CommandPortDisable, input_port_);
   for (size_t i = 0; i < input_buffers_.size(); ++i) {
     OMX_ERRORTYPE error =
         OMX_FreeBuffer(handle_, input_port_, input_buffers_[i]);
     SB_DCHECK(error == OMX_ErrorNone);
   }
   WaitForCommandCompletion();

   SendCommand(OMX_CommandPortDisable, output_port_);
   for (size_t i = 0; i < output_buffers_.size(); ++i) {
     OMX_ERRORTYPE error =
         OMX_FreeBuffer(handle_, output_port_, output_buffers_[i]);
     SB_DCHECK(error == OMX_ErrorNone);
   }
   output_buffers_.clear();
   WaitForCommandCompletion();

   SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateLoaded);
   OMX_FreeHandle(handle_);
 }

 void OpenMaxComponent::Start() {
   EnableInputPortAndAllocateBuffers();
   SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateExecuting);
 }

 void OpenMaxComponent::Flush() {
   SendCommandAndWaitForCompletion(OMX_CommandFlush, input_port_);
   SendCommandAndWaitForCompletion(OMX_CommandFlush, output_port_);
 }

 void OpenMaxComponent::WriteData(const void* data,
                                  size_t size,
                                  SbTime timestamp) {
   size_t offset = 0;

   while (offset != size) {
     OMX_BUFFERHEADERTYPE* buffer_header = GetUnusedInputBuffer();

     int size_to_append = std::min(size - offset, buffer_header->nAllocLen);
     buffer_header->nOffset = 0;
     buffer_header->nFilledLen = size_to_append;
     buffer_header->nFlags = 0;

     buffer_header->nTimeStamp.nLowPart = timestamp;
     buffer_header->nTimeStamp.nHighPart = timestamp >> 32;

     memcpy(buffer_header->pBuffer, (const char*)data + offset, size_to_append);
     offset += size_to_append;

     OMX_ERRORTYPE error = OMX_EmptyThisBuffer(handle_, buffer_header);
     SB_DCHECK(error == OMX_ErrorNone);
   }
 }

 void OpenMaxComponent::WriteEOS() {
   OMX_BUFFERHEADERTYPE* buffer_header = GetUnusedInputBuffer();

   buffer_header->nOffset = 0;
   buffer_header->nFilledLen = 0;
   buffer_header->nFlags = OMX_BUFFERFLAG_EOS;

   OMX_ERRORTYPE error = OMX_EmptyThisBuffer(handle_, buffer_header);
   SB_DCHECK(error == OMX_ErrorNone);
 }

 OMX_BUFFERHEADERTYPE* OpenMaxComponent::PeekNextOutputBuffer() {
   {
     ScopedLock scoped_lock(mutex_);

     if (!output_setting_changed_) {
       return NULL;
     }
   }

   if (!output_port_enabled_) {
     EnableOutputPortAndAllocateBuffer();
   }

   ScopedLock scoped_lock(mutex_);
   return filled_output_buffers_.empty() ? NULL : filled_output_buffers_.front();
 }

 void OpenMaxComponent::DropNextOutputBuffer() {
   OMX_BUFFERHEADERTYPE* buffer = NULL;
   {
     ScopedLock scoped_lock(mutex_);
     SB_DCHECK(!filled_output_buffers_.empty());
     buffer = filled_output_buffers_.front();
     filled_output_buffers_.pop();
   }
   buffer->nFilledLen = 0;
   OMX_ERRORTYPE error = OMX_FillThisBuffer(handle_, buffer);
   SB_DCHECK(error == OMX_ErrorNone);
 }

 void OpenMaxComponent::SendCommand(OMX_COMMANDTYPE command, int param) {
   OMX_ERRORTYPE error = OMX_SendCommand(handle_, command, param, NULL);
   SB_DCHECK(error == OMX_ErrorNone);
 }

 void OpenMaxComponent::WaitForCommandCompletion() {
   for (;;) {
     ScopedLock scoped_lock(mutex_);
     for (EventDescriptions::iterator iter = event_descriptions_.begin();
          iter != event_descriptions_.end(); ++iter) {
       if (iter->event == OMX_EventCmdComplete) {
         event_descriptions_.erase(iter);
         return;
       }
       // Special case for OMX_CommandStateSet.
       if (iter->event == OMX_EventError && iter->data1 == OMX_ErrorSameState) {
         event_descriptions_.erase(iter);
         return;
       }
     }
     condition_variable_.Wait();
   }
 }

 void OpenMaxComponent::SendCommandAndWaitForCompletion(OMX_COMMANDTYPE command,
                                                        int param) {
   SendCommand(command, param);
   WaitForCommandCompletion();
 }

 void OpenMaxComponent::EnableInputPortAndAllocateBuffers() {
   SB_DCHECK(input_buffers_.empty());

   OMXParamPortDefinition port_definition;
   GetInputPortParam(&port_definition);
   if (OnEnableInputPort(&port_definition)) {
     SetPortParam(port_definition);
   }

   SendCommand(OMX_CommandPortEnable, input_port_);

   for (int i = 0; i < port_definition.nBufferCountActual; ++i) {
     OMX_BUFFERHEADERTYPE* buffer;
     OMX_ERRORTYPE error = OMX_AllocateBuffer(handle_, &buffer, input_port_,
                                              NULL, port_definition.nBufferSize);
     SB_DCHECK(error == OMX_ErrorNone);
     input_buffers_.push_back(buffer);
     unused_input_buffers_.push(buffer);
   }

   WaitForCommandCompletion();
 }

 void OpenMaxComponent::EnableOutputPortAndAllocateBuffer() {
   SB_DCHECK(!output_port_enabled_);

   GetOutputPortParam(&output_port_definition_);
   if (OnEnableOutputPort(&output_port_definition_)) {
     SetPortParam(output_port_definition_);
   }

   SendCommand(OMX_CommandPortEnable, output_port_);

   output_buffers_.reserve(output_port_definition_.nBufferCountActual);
   for (int i = 0; i < output_port_definition_.nBufferCountActual; ++i) {
     OMX_BUFFERHEADERTYPE* buffer;
     OMX_ERRORTYPE error =
         OMX_AllocateBuffer(handle_, &buffer, output_port_, NULL,
                            output_port_definition_.nBufferSize);
     SB_DCHECK(error == OMX_ErrorNone);
     output_buffers_.push_back(buffer);
   }

   WaitForCommandCompletion();

   output_port_enabled_ = true;

   for (size_t i = 0; i < output_buffers_.size(); ++i) {
     output_buffers_[i]->nFilledLen = 0;
     OMX_ERRORTYPE error = OMX_FillThisBuffer(handle_, output_buffers_[i]);
     SB_DCHECK(error == OMX_ErrorNone);
   }
 }

 OMX_BUFFERHEADERTYPE* OpenMaxComponent::GetUnusedInputBuffer() {
   for (;;) {
     {
       ScopedLock scoped_lock(mutex_);
       if (!unused_input_buffers_.empty()) {
         OMX_BUFFERHEADERTYPE* buffer_header = unused_input_buffers_.front();
         unused_input_buffers_.pop();
         return buffer_header;
       }
     }
     SbThreadSleep(kSbTimeMillisecond);
   }
   SB_NOTREACHED();
   return NULL;
 }

 OMX_ERRORTYPE OpenMaxComponent::OnEvent(OMX_EVENTTYPE event,
                                         OMX_U32 data1,
                                         OMX_U32 data2,
                                         OMX_PTR event_data) {
   if (event == OMX_EventError && data1 != OMX_ErrorSameState) {
     SB_NOTREACHED() << "OMX_EventError received with " << std::hex << data1
                     << " " << data2;
     return OMX_ErrorNone;
   }

   ScopedLock scoped_lock(mutex_);
   if (event == OMX_EventPortSettingsChanged && data1 == output_port_) {
     output_setting_changed_ = true;
     return OMX_ErrorNone;
   }
   EventDescription event_desc;
   event_desc.event = event;
   event_desc.data1 = data1;
   event_desc.data2 = data2;
   event_desc.event_data = event_data;
   event_descriptions_.push_back(event_desc);
   condition_variable_.Signal();

   return OMX_ErrorNone;
 }

 OMX_ERRORTYPE OpenMaxComponent::OnEmptyBufferDone(
     OMX_BUFFERHEADERTYPE* buffer) {
   ScopedLock scoped_lock(mutex_);
   unused_input_buffers_.push(buffer);
 }

 void OpenMaxComponent::OnFillBufferDone(OMX_BUFFERHEADERTYPE* buffer) {
   ScopedLock scoped_lock(mutex_);
   filled_output_buffers_.push(buffer);
 }

 // static
 OMX_ERRORTYPE OpenMaxComponent::EventHandler(OMX_HANDLETYPE handle,
                                              OMX_PTR app_data,
                                              OMX_EVENTTYPE event,
                                              OMX_U32 data1,
                                              OMX_U32 data2,
                                              OMX_PTR event_data) {
   SB_DCHECK(app_data != NULL);
   OpenMaxComponent* component = reinterpret_cast<OpenMaxComponent*>(app_data);
   SB_DCHECK(handle == component->handle_);

   return component->OnEvent(event, data1, data2, event_data);
 }

 // static
 OMX_ERRORTYPE OpenMaxComponent::EmptyBufferDone(OMX_HANDLETYPE handle,
                                                 OMX_PTR app_data,
                                                 OMX_BUFFERHEADERTYPE* buffer) {
   SB_DCHECK(app_data != NULL);
   OpenMaxComponent* component = reinterpret_cast<OpenMaxComponent*>(app_data);
   SB_DCHECK(handle == component->handle_);

   return component->OnEmptyBufferDone(buffer);
 }

 // static
 OMX_ERRORTYPE OpenMaxComponent::FillBufferDone(OMX_HANDLETYPE handle,
                                                OMX_PTR app_data,
                                                OMX_BUFFERHEADERTYPE* buffer) {
   SB_DCHECK(app_data != NULL);
   OpenMaxComponent* component = reinterpret_cast<OpenMaxComponent*>(app_data);
   SB_DCHECK(handle == component->handle_);

   component->OnFillBufferDone(buffer);

   return OMX_ErrorNone;
 }

 }  // namespace open_max
 }  // namespace shared
 }  // namespace raspi
 }  // namespace starboard
	// Copyright 2016 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "starboard/raspi/shared/open_max/open_max_component.h"

	#include <algorithm>

	#include "starboard/configuration.h"
	#include "starboard/once.h"
	#include "starboard/thread.h"

	namespace starboard {
	namespace raspi {
	namespace shared {
	namespace open_max {

	namespace {

	const int kInvalidPort = -1;

	OMX_INDEXTYPE kPortTypes[] = {OMX_IndexParamAudioInit, OMX_IndexParamVideoInit,
	OMX_IndexParamImageInit, OMX_IndexParamOtherInit};

	SbOnceControl s_open_max_initialization_once = SB_ONCE_INITIALIZER;

	void DoInitializeOpenMax() {
	OMX_ERRORTYPE error = OMX_Init();
	SB_DCHECK(error == OMX_ErrorNone);
	}

	void InitializeOpenMax() {
	bool initialized =
	SbOnce(&s_open_max_initialization_once, DoInitializeOpenMax);
	SB_DCHECK(initialized);
	}

	} // namespace

	OpenMaxComponent::OpenMaxComponent(const char* name)
	: condition_variable_(mutex_),
	handle_(NULL),
	input_port_(kInvalidPort),
	output_port_(kInvalidPort),
	output_setting_changed_(false),
	output_port_enabled_(false) {
	InitializeOpenMax();

	OMX_CALLBACKTYPE callbacks;
	callbacks.EventHandler = OpenMaxComponent::EventHandler;
	callbacks.EmptyBufferDone = OpenMaxComponent::EmptyBufferDone;
	callbacks.FillBufferDone = OpenMaxComponent::FillBufferDone;

	OMX_ERRORTYPE error =
	OMX_GetHandle(&handle_, const_cast<char*>(name), this, &callbacks);
	SB_DCHECK(error == OMX_ErrorNone);

	for (size_t i = 0; i < SB_ARRAY_SIZE(kPortTypes); ++i) {
	OMX_PORT_PARAM_TYPE port;
	port.nSize = sizeof(OMX_PORT_PARAM_TYPE);
	port.nVersion.nVersion = OMX_VERSION;

	error = OMX_GetParameter(handle_, kPortTypes[i], &port);
	if (error == OMX_ErrorNone && port.nPorts == 2) {
	input_port_ = port.nStartPortNumber;
	output_port_ = input_port_ + 1;
	SendCommandAndWaitForCompletion(OMX_CommandPortDisable, input_port_);
	SendCommandAndWaitForCompletion(OMX_CommandPortDisable, output_port_);
	break;
	}
	}
	SB_CHECK(input_port_ != kInvalidPort);
	SB_CHECK(output_port_ != kInvalidPort);
	SB_DLOG(INFO) << "Opened \"" << name << "\" with port " << input_port_
	<< " and " << output_port_;

	SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateIdle);
	}

	OpenMaxComponent::~OpenMaxComponent() {
	if (!handle_) {
	return;
	}
	SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateIdle);

	SendCommandAndWaitForCompletion(OMX_CommandFlush, input_port_);
	SendCommandAndWaitForCompletion(OMX_CommandFlush, output_port_);

	SendCommand(OMX_CommandPortDisable, input_port_);
	for (size_t i = 0; i < input_buffers_.size(); ++i) {
	OMX_ERRORTYPE error =
	OMX_FreeBuffer(handle_, input_port_, input_buffers_[i]);
	SB_DCHECK(error == OMX_ErrorNone);
	}
	WaitForCommandCompletion();

	SendCommand(OMX_CommandPortDisable, output_port_);
	for (size_t i = 0; i < output_buffers_.size(); ++i) {
	OMX_ERRORTYPE error =
	OMX_FreeBuffer(handle_, output_port_, output_buffers_[i]);
	SB_DCHECK(error == OMX_ErrorNone);
	}
	output_buffers_.clear();
	WaitForCommandCompletion();

	SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateLoaded);
	OMX_FreeHandle(handle_);
	}

	void OpenMaxComponent::Start() {
	EnableInputPortAndAllocateBuffers();
	SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateExecuting);
	}

	void OpenMaxComponent::Flush() {
	SendCommandAndWaitForCompletion(OMX_CommandFlush, input_port_);
	SendCommandAndWaitForCompletion(OMX_CommandFlush, output_port_);
	}

	void OpenMaxComponent::WriteData(const void* data,
	size_t size,
	SbTime timestamp) {
	size_t offset = 0;

	while (offset != size) {
	OMX_BUFFERHEADERTYPE* buffer_header = GetUnusedInputBuffer();

	int size_to_append = std::min(size - offset, buffer_header->nAllocLen);
	buffer_header->nOffset = 0;
	buffer_header->nFilledLen = size_to_append;
	buffer_header->nFlags = 0;

	buffer_header->nTimeStamp.nLowPart = timestamp;
	buffer_header->nTimeStamp.nHighPart = timestamp >> 32;

	memcpy(buffer_header->pBuffer, (const char*)data + offset, size_to_append);
	offset += size_to_append;

	OMX_ERRORTYPE error = OMX_EmptyThisBuffer(handle_, buffer_header);
	SB_DCHECK(error == OMX_ErrorNone);
	}
	}

	void OpenMaxComponent::WriteEOS() {
	OMX_BUFFERHEADERTYPE* buffer_header = GetUnusedInputBuffer();

	buffer_header->nOffset = 0;
	buffer_header->nFilledLen = 0;
	buffer_header->nFlags = OMX_BUFFERFLAG_EOS;

	OMX_ERRORTYPE error = OMX_EmptyThisBuffer(handle_, buffer_header);
	SB_DCHECK(error == OMX_ErrorNone);
	}

	OMX_BUFFERHEADERTYPE* OpenMaxComponent::PeekNextOutputBuffer() {
	{
	ScopedLock scoped_lock(mutex_);

	if (!output_setting_changed_) {
	return NULL;
	}
	}

	if (!output_port_enabled_) {
	EnableOutputPortAndAllocateBuffer();
	}

	ScopedLock scoped_lock(mutex_);
	return filled_output_buffers_.empty() ? NULL : filled_output_buffers_.front();
	}

	void OpenMaxComponent::DropNextOutputBuffer() {
	OMX_BUFFERHEADERTYPE* buffer = NULL;
	{
	ScopedLock scoped_lock(mutex_);
	SB_DCHECK(!filled_output_buffers_.empty());
	buffer = filled_output_buffers_.front();
	filled_output_buffers_.pop();
	}
	buffer->nFilledLen = 0;
	OMX_ERRORTYPE error = OMX_FillThisBuffer(handle_, buffer);
	SB_DCHECK(error == OMX_ErrorNone);
	}

	void OpenMaxComponent::SendCommand(OMX_COMMANDTYPE command, int param) {
	OMX_ERRORTYPE error = OMX_SendCommand(handle_, command, param, NULL);
	SB_DCHECK(error == OMX_ErrorNone);
	}

	void OpenMaxComponent::WaitForCommandCompletion() {
	for (;;) {
	ScopedLock scoped_lock(mutex_);
	for (EventDescriptions::iterator iter = event_descriptions_.begin();
	iter != event_descriptions_.end(); ++iter) {
	if (iter->event == OMX_EventCmdComplete) {
	event_descriptions_.erase(iter);
	return;
	}
	// Special case for OMX_CommandStateSet.
	if (iter->event == OMX_EventError && iter->data1 == OMX_ErrorSameState) {
	event_descriptions_.erase(iter);
	return;
	}
	}
	condition_variable_.Wait();
	}
	}

	void OpenMaxComponent::SendCommandAndWaitForCompletion(OMX_COMMANDTYPE command,
	int param) {
	SendCommand(command, param);
	WaitForCommandCompletion();
	}

	void OpenMaxComponent::EnableInputPortAndAllocateBuffers() {
	SB_DCHECK(input_buffers_.empty());

	OMXParamPortDefinition port_definition;
	GetInputPortParam(&port_definition);
	if (OnEnableInputPort(&port_definition)) {
	SetPortParam(port_definition);
	}

	SendCommand(OMX_CommandPortEnable, input_port_);

	for (int i = 0; i < port_definition.nBufferCountActual; ++i) {
	OMX_BUFFERHEADERTYPE* buffer;
	OMX_ERRORTYPE error = OMX_AllocateBuffer(handle_, &buffer, input_port_,
	NULL, port_definition.nBufferSize);
	SB_DCHECK(error == OMX_ErrorNone);
	input_buffers_.push_back(buffer);
	unused_input_buffers_.push(buffer);
	}

	WaitForCommandCompletion();
	}

	void OpenMaxComponent::EnableOutputPortAndAllocateBuffer() {
	SB_DCHECK(!output_port_enabled_);

	GetOutputPortParam(&output_port_definition_);
	if (OnEnableOutputPort(&output_port_definition_)) {
	SetPortParam(output_port_definition_);
	}

	SendCommand(OMX_CommandPortEnable, output_port_);

	output_buffers_.reserve(output_port_definition_.nBufferCountActual);
	for (int i = 0; i < output_port_definition_.nBufferCountActual; ++i) {
	OMX_BUFFERHEADERTYPE* buffer;
	OMX_ERRORTYPE error =
	OMX_AllocateBuffer(handle_, &buffer, output_port_, NULL,
	output_port_definition_.nBufferSize);
	SB_DCHECK(error == OMX_ErrorNone);
	output_buffers_.push_back(buffer);
	}

	WaitForCommandCompletion();

	output_port_enabled_ = true;

	for (size_t i = 0; i < output_buffers_.size(); ++i) {
	output_buffers_[i]->nFilledLen = 0;
	OMX_ERRORTYPE error = OMX_FillThisBuffer(handle_, output_buffers_[i]);
	SB_DCHECK(error == OMX_ErrorNone);
	}
	}

	OMX_BUFFERHEADERTYPE* OpenMaxComponent::GetUnusedInputBuffer() {
	for (;;) {
	{
	ScopedLock scoped_lock(mutex_);
	if (!unused_input_buffers_.empty()) {
	OMX_BUFFERHEADERTYPE* buffer_header = unused_input_buffers_.front();
	unused_input_buffers_.pop();
	return buffer_header;
	}
	}
	SbThreadSleep(kSbTimeMillisecond);
	}
	SB_NOTREACHED();
	return NULL;
	}

	OMX_ERRORTYPE OpenMaxComponent::OnEvent(OMX_EVENTTYPE event,
	OMX_U32 data1,
	OMX_U32 data2,
	OMX_PTR event_data) {
	if (event == OMX_EventError && data1 != OMX_ErrorSameState) {
	SB_NOTREACHED() << "OMX_EventError received with " << std::hex << data1
	<< " " << data2;
	return OMX_ErrorNone;
	}

	ScopedLock scoped_lock(mutex_);
	if (event == OMX_EventPortSettingsChanged && data1 == output_port_) {
	output_setting_changed_ = true;
	return OMX_ErrorNone;
	}
	EventDescription event_desc;
	event_desc.event = event;
	event_desc.data1 = data1;
	event_desc.data2 = data2;
	event_desc.event_data = event_data;
	event_descriptions_.push_back(event_desc);
	condition_variable_.Signal();

	return OMX_ErrorNone;
	}

	OMX_ERRORTYPE OpenMaxComponent::OnEmptyBufferDone(
	OMX_BUFFERHEADERTYPE* buffer) {
	ScopedLock scoped_lock(mutex_);
	unused_input_buffers_.push(buffer);
	}

	void OpenMaxComponent::OnFillBufferDone(OMX_BUFFERHEADERTYPE* buffer) {
	ScopedLock scoped_lock(mutex_);
	filled_output_buffers_.push(buffer);
	}

	// static
	OMX_ERRORTYPE OpenMaxComponent::EventHandler(OMX_HANDLETYPE handle,
	OMX_PTR app_data,
	OMX_EVENTTYPE event,
	OMX_U32 data1,
	OMX_U32 data2,
	OMX_PTR event_data) {
	SB_DCHECK(app_data != NULL);
	OpenMaxComponent* component = reinterpret_cast<OpenMaxComponent*>(app_data);
	SB_DCHECK(handle == component->handle_);

	return component->OnEvent(event, data1, data2, event_data);
	}

	// static
	OMX_ERRORTYPE OpenMaxComponent::EmptyBufferDone(OMX_HANDLETYPE handle,
	OMX_PTR app_data,
	OMX_BUFFERHEADERTYPE* buffer) {
	SB_DCHECK(app_data != NULL);
	OpenMaxComponent* component = reinterpret_cast<OpenMaxComponent*>(app_data);
	SB_DCHECK(handle == component->handle_);

	return component->OnEmptyBufferDone(buffer);
	}

	// static
	OMX_ERRORTYPE OpenMaxComponent::FillBufferDone(OMX_HANDLETYPE handle,
	OMX_PTR app_data,
	OMX_BUFFERHEADERTYPE* buffer) {
	SB_DCHECK(app_data != NULL);
	OpenMaxComponent* component = reinterpret_cast<OpenMaxComponent*>(app_data);
	SB_DCHECK(handle == component->handle_);

	component->OnFillBufferDone(buffer);

	return OMX_ErrorNone;
	}

	} // namespace open_max
	} // namespace shared
	} // namespace raspi
	} // namespace starboard