Test program for OpenMAX video decoding

media/omx/omx_video_decoder.h

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.  Use of this
 // source code is governed by a BSD-style license that can be found in the
 // LICENSE file.
 //
 // An object that works with an OpenMAX component for video decoding.
 // Operations on this object are all asynchronous and this object
 // requires a message loop that it works on.
 //
 // USAGES
 //
 // // Initialization.
 // MessageLoop message_loop;
 // OmxVideoDecoder* decoder = new OmxVideoDecoder(&message_loop);
-// decoder->Setup(kCodecH264);
+// decoder->Setup(component_name, kCodecH264);
 // decoder->SetErrorCallback(NewCallback(this, &Client::ErrorCallback));
 //
 // // Start is asynchronous. But we don't need to wait for it to proceed.
 // decoder->Start();
 //
 // // We can start giving buffer to the decoder right after start. It will
 // // queue the input buffers and output requests and process them until
 // // the decoder can actually process them.
 // for (int i = 0; i < kInitialBuffers; ++i) {
 //   InputBuffer* buffer = PrepareInitialInputBuffer();
@@ skipping 72 matching lines @@
     kCodecNone,
     kCodecH264,
     kCodecMpeg4,
     kCodecH263,
     kCodecVc1,
   };
 
   OmxVideoDecoder(MessageLoop* message_loop);
   virtual ~OmxVideoDecoder();
 
-  // Set the input codec format.
-  // TODO(hclam): Add input format and output format.
-  void Setup(Codec codec);
+  // Set the component name and input codec format.
+  // TODO(hclam): Add input format and output format. Also remove |component|.
+  void Setup(const char* component, Codec codec);
 
   // Set the error callback. In case of error the callback will be called.
   void SetErrorCallback(Callback* callback);
 
   // Start the decoder, this will start the initialization asynchronously.
   // Client can start feeding to and reading from the decoder.
   void Start();
 
   // Stop the decoder. When the decoder is fully stopped, |callback|
   // is called.
@@ skipping 162 matching lines @@
 
   // |state_| records the current state. During state transition
   // |next_state_| is the next state that this machine will transition
   // to. After a state transition is completed and the state becomes
   // stable then |next_state_| equals |state_|. Inequality can be
   // used to detect a state transition.
   // These two members are read and written only on |message_loop_|.
   State state_;
   State next_state_;
 
+  // TODO(hclam): We should keep a list of component names.
+  const char* component_;
   Codec codec_;
   MessageLoop* message_loop_;
 
   scoped_ptr<Callback> stop_callback_;
   scoped_ptr<Callback> error_callback_;
 
   // Input and output queue for encoded data and decoded frames.
   typedef std::pair<InputBuffer*, FeedCallback*> InputUnit;
   std::queue<InputUnit> input_queue_;
   std::queue<ReadCallback*> output_queue_;
 
   // Input and output buffers that we can use to feed the decoder.
   std::queue<OMX_BUFFERHEADERTYPE*> available_input_buffers_;
   std::queue<OMX_BUFFERHEADERTYPE*> available_output_buffers_;
 };
 
 }  // namespace media