haiku/headers/private/media/experimental/MediaExtractorAddOn.h

extern "C" {
  // Your addon should implement this function.
  // Return a new instance of your BMediaExtractorAddOn subclass.
  // This function will be called multiple times, and should return a
  // new instance each time.  Return NULL if allocation fails.
  BMediaExtractorAddOn * instantiate_media_extractor_add_on();
}

// Your add-on must implement a subclass of this class
class BMediaExtractorAddOn
{
public:
  BMediaExtractorAddOn(void);
  virtual ~BMediaExtractorAddOn(void);

  //// stateless functions
  // these should work without dependency on a current stream

/* begin BFileInterface functions */
  // These are used to enumerate the set of file formats that this
  // extractor is prepared to read from.  Implementing these meaningfully
  // is important for discovering all types supported by the system.

  // Implement per BFileInterface::GetNextFileFormat
  //
  // Return codes:
  // B_OK : No error
  // B_ERROR : No more formats
  // GetNextInputFormat: required for BFileInterface functionality
  virtual status_t GetNextInputFormat(int32 * cookie,
                                      media_file_format * outFormat) = 0;
  // Implement per BFileInterface::DisposeFileFormatCookie
  // DisposeInputFormatCookie: required for BFileInterface functionality
  virtual void DisposeInputFormatCookie(int32 cookie) = 0;

/* begin transcoding functions */
  // These are used to enumerate the set of file formats that this
  // extractor is prepared to transcode to.  The default implementation
  // simply returns no support.

  // Implement per BFileInterface::GetNextFileFormat
  //
  // Return codes:
  // B_OK : No error
  // B_ERROR : No more formats
  virtual status_t GetNextOutputFormat(int32 * cookie,
                                       media_file_format * outFormat);
  // Implement per BFileInterface::DisposeFileFormatCookie
  virtual void DisposeOutputFormatCookie(int32 cookie);
/* end transcoding functions */
/* end BFileInterface functions */
  
/* begin BMediaAddOn functions */
  // These are used to discover an extractors quality rating for a
  // particular media format.
  // Implement per BMediaAddOn::SniffType
  //
  // Return codes:
  // B_OK : No error
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle that mime type
  virtual status_t SniffInputType(BMimeType & mimeType, float * outQuality) = 0;
/* begin transcoding function */
  virtual status_t SniffOutputType(BMimeType & mimeType, float * outQuality);
/* end transcoding function */
/* end BMediaAddOn functions */

  // Same as above, but for a media file format
  // The default implementation of this will iterate through your formats using
  // the appropriate interface from above, and simply return 0 for the quality
  // if it finds a matching supported format.
  //
  // Return codes:
  // B_OK : No error
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle that format
  virtual status_t SniffInputFormat(const media_file_format & format, float * outQuality);
/* begin transcoding function */
  virtual status_t SniffOutputFormat(const media_file_format & format, float * outQuality);
/* end transcoding function */

  //// state creation functions
  // calling these functions shouldn't affect the results of the stateless functions

  // Sets the current stream to source or destination
  // The default implementation for the BDataIO SetSource is to wrap
  // the BDataIO object in a buffer and call the BPositionIO SetSource.
  // The default implementation for the BFile SetSource is to send the
  // call directly to BPositionIO.  Note that it is highly recommended
  // to utilize the BNode properties of the BNodeIO/BFile object in
  // order to dynamically update your extractor state when the file
  // changes.  It is also recommended to use the BNode properties in
  // order to access the attributes of the source file; store or load
  // file specific extractor properties from here.
  // Note: the extractor is not require to return B_MEDIA_NO_HANDLER at
  // this point.  However, calling any stateful function after this
  // should return B_MEDIA_NO_HANDLER.
  //
  // Return codes:
  // B_OK : No error
  // B_NO_MEMORY : Storage for the buffer could not be allocated.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle that format
  virtual status_t SetSource(const BFile * source);
  virtual status_t SetSource(const entry_ref * source, int32 flags = 0);
  virtual status_t SetSource(const BDataIO * source);
/* begin transcoding functions */
  virtual status_t SetDestination(const BFile * source);
  virtual status_t SetDestination(const entry_ref * source, int32 flags = 0);
  virtual status_t SetDestination(const BDataIO * source);
/* end transcoding functions */

  //// stateful functions
  // Calling these functions shouldn't affect the results of the stateless functions.
  // Calling these functions before calling a state creation function should return
  // B_NO_INIT.  Calling these functions after calling a state creation function with
  // an invalid argument should return B_MEDIA_NO_HANDLER.  Generally these
  // functions may also return any appropriate Storage Kit/File System Errors, such
  // as B_FILE_NOT_FOUND, B_BUSTED_PIPE, etc.

  // inspired by BMediaFile::GetFileFormatInfo
  //
  // Fills the specified media_file_format structure with
  // information describing the file format of the stream
  // currently referenced by the BEncoder.
  // 
  // Return codes:
  // B_OK        : No error
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_NO_MEMORY : Storage for part of the media_file_format
  //               object couldn't be allocated.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t GetFileFormatInfo(media_file_format * mfi) = 0;
                             
  // The extractor should implement this function in the
  // manner described for BFileInterface::SniffRef, except that
  // it uses the current Source instead of an entry_ref
  //
  // Return codes:
  // B_OK : No error
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t Sniff(char * outMimeType, float * outQuality) = 0;

  // implement per BMediaTrack::AddChunk(void)
  // 
  // Return codes:
  // B_OK        : No error
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t WriteChunk(int32 type,
                              const void * data,
                              size_t size);

/* begin weird function that is missing but parallels add chunk */
  // implement per BMediaTrack::ReadChunk(void) <- missing????
  // umm.. has the same semantics as AddChunk, yeah that's it...
  // 
  // Return codes:
  // B_OK        : No error
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t ReadChunk(int32 * outType,
                             const void * outData,
                             size_t * outSize);
/* end weird function that is missing but parallels add chunk */

  // The extractor should do any cleanup required.  After
  // this function returns, the source object should be
  // closed and deleted by the caller, not by Close().
  // The default implementation simply returns B_OK.
  //
  // Return codes:
  // B_OK : No error
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t Close(void);

  //// shared state functions
  // The ParameterWeb interface is used to publish both file specific
  // and extractor specific options.  Accessing a file specific parameter
  // before calling a state creation function should return B_NO_INIT.
  // Accessing a file parameter after calling a state creation function
  // with an invalid argument should return B_MEDIA_NO_HANDLER.  Accessing
  // extractor specific options should never return these errors, but may
  // return other errors.

  // the extractor should provide several basic parameters
  // through this interface, such as B_TRACK_COUNT, and B_DURATION
  // see also BMediaFile::GetParameterValue
  // hmmm... how to pick which stream parameters apply to?
  // could use a bitwise or with B_OUTPUT_STREAM (and a
  // B_INPUT_STREAM for completeness)
  //
  // Return codes:
  // B_OK : No error
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t GetParameterValue(int32 id, const void * value, 
                                     size_t * size) = 0;

  // the extractor may optionally supply parameters for the
  // user to configure, such as buffering information(?)
  // see also BMediaFile::SetParameterValue
  //
  // Return codes:
  // B_OK : No error
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t SetParameterValue(int32 id, const void * value,
                                     size_t size);

  // The extractor may return a BParameterWeb for browsing or
  // configuring the extractor's parameters.  Returns NULL if the
  // extractor doesn't support this.  The default implementation
  // simply returns NULL.  Note: if the Source is not in a good
  // state, this web may not include file specific parameters.
  //
  // As a suggestion you should use groups to gather parameters
  // related to the encoder and separate them from parameters
  // related to the input stream and output stream (if applicable)
  //  
  // See also BMediaFile::Web
  virtual BParameterWeb * Web(void) { return NULL; }

  // The extractor may return a BView for browsing or configuring
  // the extractor's parameters.  Returns NULL if the extractor
  // doesn't support this.  The default implementation simply
  // returns NULL.
  virtual BView * GetParameterView(void) (void) { return NULL; }

/* begin seek/sync functions for the extractor */
  // The extractor will seek first on the seek track, just like
  // BMediaTrack::SeekToTime.  Like SeekToTime, it accepts a flag
  // argument which tells how to find the nearest acceptable frame.
  // After finding this frame, it will also seek any other open
  // streams in an extractor-dependent fashion.  Usually the seek
  // stream will be a video stream.  If seeked to a keyframe, for
  // example, the audio stream will be seeked to an appropriate time.
  //
  // This may be more efficient than seeking the seek track through
  // the BMediaTrack interface, and then calling Sync() here.  It
  // should not be less efficient.
  //
  // See also BMediaTrack::SeekToTime
  // see above for additions to media_seek_type (used for flags)
  // seekMode per BFile::Seek, only SEEK_SET is required
  //
  // Return codes:
  // B_OK : No error
  // B_UNSUPPORTED : This extractor does not support general seeking
  //                 for this stream.
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t SeekToTime(bigtime_t * ioTime,
                              int32 mediaSeekFlags = 0,
                              int32 seekMode = 0) = 0;
  
  // The extractor will seek first on the seek track, just like
  // BMediaTrack::SeekToFrame.  Like SeekToFrame, it accepts a flag
  // argument which tells how to find the nearest acceptable frame.
  // After finding this frame, it will also seek any other open
  // streams in an extractor-dependent fashion.  Usually the seek
  // stream will be a video stream.  If seeked to a keyframe, for
  // example, the audio stream will be seeked to an appropriate time.
  //
  // This may be more efficient than seeking the seek track through
  // the BMediaTrack interface, and then calling Sync() here.  It
  // should not be less efficient.
  //
  // See also BMediaTrack::SeekToFrame
  // see above for additions to media_seek_type (used for flags)
  // seekMode per BFile::Seek, only SEEK_SET is required
  //
  // Return codes:
  // B_OK : No error
  // B_UNSUPPORTED : This extractor does not support general seeking
  //                 for this stream.
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t SeekToFrame(int64 * ioFrame,
                               int32 mediaSeekFlags = 0,
                               int32 seekMode = 0) = 0;

/* begin seek extensions functions */
  // The extractor will seek first on the seek track.  It goes to
  // a position defined by ioChunk*chunkSize, where chunkSize is
  // defined by the decoder.  For example, some streams are not byte
  // streams, but rather bitstreams.  In this case the chunkSize may
  // correspond to 1 bit.  Like the other MediaTrack Seeks, it
  // accepts a flag argument which tells how to find the nearest
  // acceptable frame.
  // After finding this frame, it will also seek any other open
  // streams in an extractor-dependent fashion.  Usually the seek
  // stream will be a video stream.  If seeked to a keyframe, for
  // example, the audio stream will be seeked to an appropriate time.
  //
  // This may be more efficient than seeking the seek track through
  // the BMediaTrack interface, and then calling Sync() here.  It
  // should not be less efficient.
  //
  // see above for additions to media_seek_type (used for flags)
  // seekMode per BFile::Seek, only SEEK_SET is required
  //
  // Return codes:
  // B_OK : No error
  // B_UNSUPPORTED : This extractor does not support general seeking
  //                 for this stream.
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t SeekToChunk(int64 * ioChunk,
                               int32 mediaSeekFlags = 0,
                               int32 seekMode = 0) = 0;
  
  // The extractor will seek first on the seek track.  It goes to a
  // position defined by numerator/(duration of this file).  For
  // example: Seek(LONG_LONG_MAX/2) would seek halfway through the
  // stream.  Like the other MediaTrack Seeks, it accepts a flag
  // argument which tells how to find the nearest acceptable frame.
  // If the seekMode is SEEK_SET it will seek a fraction of the way
  // back to the beginning from the current location.  If the seekMode
  // is SEEK_END it will seek a fraction of the way to the end from
  // the current location.  If the seekMode is SEEK_CUR it will seek
  // as above. (fraction of the entire file duration)
  // After finding this frame, it will also seek any other open
  // streams in an extractor-dependent fashion.  Usually the seek
  // stream will be a video stream.  If seeked to a keyframe, for
  // example, the audio stream will be seeked to an appropriate time.
  //
  // This may be a lot more efficient than seeking to a time or frame
  // for some streams. (in particular, nonindexed streams)
  //
  // This may be more efficient than seeking the seek track through
  // the BMediaTrack interface, and then calling Sync() here.  It
  // should not be less efficient.
  //
  // Note: because the duration may change over time (if the file is
  // being written to, for example) the result of seeking with a
  // particular numerator may also change.  It will usually be later,
  // but could also be earlier.
  //
  // see above for additions to media_seek_type (used for flags)
  // seekMode per BFile::Seek, only SEEK_CUR is required
  //
  // Return codes:
  // B_OK : No error
  // B_UNSUPPORTED : This extractor does not support general seeking
  //                 for this stream.
  // B_NO_INIT     : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t Seek(int64 * numerator,
                        int32 mediaSeekFlags = 0,
                        int32 seekMode = 0) = 0;
/* end seek extensions functions */

  // Using the location from the seek stream, seeks any other open
  // streams in an extractor-dependent fashion.  Usually the seek
  // stream will be a video stream.  If seeked to a keyframe, for
  // example, the audio stream will be seeked to an appropriate time.
  //
  // Note: if not supplied, the seek stream will be the current one
  // as retrieved by GetParameterValue, not zero.  Sync() will do
  // this check for you.
  //
  // Return codes:
  // B_OK : No error
  // B_UNSUPPORTED : This extractor does not support general syncing
  //                 for this stream.
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual status_t Sync(int32 seekStream = 0) = 0;
/* end seek/sync functions for the extractor */
  
  // Returns a thing that is useful for MediaTrack to do its business.
  //
  // May simply include state but will probably include a pointer back
  // to this object, and will likely call functions that are defined by
  // subclasses of this extractor.  For example, the subclass may define
  // a function like this:
  // SeekTrackToFrame(BTrack * track, int64 ioFrame, int32 flags = 0) {
  // ... }
  // and then when SeekToFrame is called on the BTrack object the work
  // would be done by the Extractor.
  //
  // Also, any track extracted using this function will be seeked by
  // the extractor seek functions.  Any track not extracted by this
  // function will not be seeked.  If the seekMode parameter is
  // supplied as SEEK_CUR the track will be seeked before being
  // returned, as per Sync().  However because this involves only
  // one track it may be more efficient than retrieving the track and
  // then calling Sync();  If seekMode is SEEK_SET then the current
  // seek time for the track will be no later than the earliest
  // seekable time.  If seekMode is SEEK_END the current seek time
  // for the track will be no earlier than the earliest seekable time.
  // Note: for non-seekable tracks, this may may no difference.
  // The default for seekMode is SEEK_SET.
  //
  // If the seek parameter is passed as false, no pre-seeking will be
  // performed on the track.  The current seek time may be arbitrary
  // or even illegal.  Attempting to decode data from the track in
  // this state will result in an error if the state is illegal.
  //
  // Return codes:
  // B_OK : No error
  // B_STREAM_NOT_FOUND
  // B_BAD_INDEX : The index supplied does not correspond to a valid
  //               track in this stream.
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  virtual BTrack * TrackAt(int32 index, int32 seekMode = 0,
                                        bool seek = true) = 0;
  
  // Disclaims interest in a particular track.  After releasing a
  // track the track will no longer be seeked by the extractor.
  //
  // Return codes:
  // B_OK : No error
  // B_BAD_TYPE  : This track does not correspond to this extractor.
  // B_NO_INIT   : The BEncoder doesn't reference a valid stream.
  // B_MEDIA_NO_HANDLER : This extractor doesn't handle this format
  status_t ReleaseTrack(BTrack * track);

protected:
  // use to negotiate the format for this track
  // straight BMediaTrack::DecodedFormat behavior
  virtual status_t NegotiateOutputFormat(BTrack * track,
                                         media_format * ioFormat) = 0;

  // get/set information about a particular track
  virtual status_t GetParameterValue(BTrack * track, int32 id,
                                     const void * value, size_t * size) = 0;
  virtual status_t SetParameterValue(BTrack * track, int32 id,
                                     const void * value, size_t size);
  virtual BParameterWeb * Web(BTrack * track) { return NULL; }
  virtual BView * GetParameterView(BTrack * track) { return NULL; }

  // seek only this particular track to the given time
  // straight BMediaTrack::SeekToTime behavior
  virtual status_t SeekToTime(BTrack * track,
                              bigtime_t * ioTime,
                              int32 mediaSeekFlags = 0,
                              int32 seekMode = 0) = 0;
  // seek only this particular track to the given frame
  // straight BMediaTrack::SeekToFrame behavior
  virtual status_t SeekToFrame(BTrack * track,
                               int64 * ioFrame,
                               int32 mediaSeekFlags = 0,
                               int32 seekMode = 0) = 0;
  // seek only this particular track to the given chunk
  // straight BMediaTrack::SeekToChunk behavior
  virtual status_t SeekToChunk(BTrack * track,
                               int64 * ioChunk,
                               int32 mediaSeekFlags = 0,
                               int32 seekMode = 0) = 0;
  // seek only this particular track to the given chunk
  // straight BMediaTrack::Seek behavior
  virtual status_t Seek(BTrack * track,
                        int64 * numerator,
                        int32 mediaSeekFlags = 0,
                        int32 seekMode = 0) = 0;

  // read a chunk from this track only
  // straight BMediaTrack::ReadChunk behavior
  virtual status_t ReadChunk(BTrack * track,
                             char ** outBuffer, int32 * ioSize,
                             media_header * outHeader = NULL) = 0;
  // read frames from this track only
  // straight BMediaTrack::ReadChunk behavior
  virtual status_t ReadFrames(BTrack * track,
                              void * outBuffer, int64 * outFrameCount,
                              media_header * outHeader = NULL,
                              media_decode_info * info = NULL) = 0;
/* begin read extensions functions */
  // read units of time from this track only
  virtual status_t ReadTime(BTrack * track,
                            void * outBuffer, int64 * outTimeCount,
                            media_header * outHeader = NULL,
                            media_decode_info * info = NULL) = 0;
  // for completeness sake?
  // read a percentage from this track only
  virtual status_t Read(BTrack * track,
                        void * outBuffer, int64 * outNumerator,
                        media_header * outHeader = NULL,
                        media_decode_info * info = NULL) = 0;
/* end read extensions functions */

private:
  // this class is used by individual tracks
  // as a private interface to the extractor
  class BTrack {
    // use to negotiate the format for this track
    virtual status_t NegotiateOutputFormat(media_format * ioFormat) {
      return BExtractor::NegotiateOutputFormat(ioFormat);
    }
    
    // access to parameters for this track
    virtual status_t GetParameterValue(int32 id, const void * value, 
                                       size_t * size) {
      return BExtractor::GetParameterValue(this,id,value,size);
    }
    virtual status_t SetParameterValue(int32 id, const void * value,
                                       size_t size) {
      return BExtractor::SetParameterValue(this,id,value,size);
    }
    virtual BParameterWeb * Web(void) {
      return BExtractor::Web(this);
    }
    virtual BView * GetParameterView(void) {
      return BExtractor::GetParameterView(this);
    }
    
    // access to seek functionality on this track
    virtual status_t SeekToTime(bigtime_t * ioTime,
                              int32 mediaSeekFlags = 0,
                              int32 seekMode = 0) {
      return BExtractor::SeekToTime(this,ioTime,mediaSeekFlags,seekMode);
    }
    virtual status_t SeekToFrame(int64 * ioFrame,
                                 int32 mediaSeekFlags = 0,
                                 int32 seekMode = 0) {
      return BExtractor::SeekToFrame(this,ioFrame,mediaSeekFlags,seekMode);
    }
    virtual status_t SeekToChunk(int64 * ioChunk,
                                 int32 mediaSeekFlags = 0,
                                 int32 seekMode = 0) {
      return BExtractor::SeekToChunk(this,ioChunk,mediaSeekFlags,seekMode);
    }
    virtual status_t Seek(int64 * numerator,
                          int32 mediaSeekFlags = 0,
                          int32 seekMode = 0) {
      return BExtractor::Seek(this,numerator,mediaSeekFlags,seekMode);
    }

    // access to readers for this track
    virtual status_t ReadChunk(char ** outBuffer, int32 * ioSize,
                               media_header * outHeader = NULL) {
      return BExtractor::ReadChunk(this,outBuffer,ioSize,outHeader);
    }
    virtual status_t ReadFrames(void * outBuffer, int64 * outFrameCount,
                                media_header * outHeader = NULL,
                                media_decode_info * info = NULL) {
      return BExtractor::ReadFrames(this,outBuffer,outFrameCount,outHeader,info);
    }
/* begin read extensions functions */
	virtual status_t ReadTime(void * outBuffer, int64 * outTimeCount,
                              media_header * outHeader = NULL,
                              media_decode_info * info = NULL) {
      return BExtractor::ReadTime(this,outBuffer,outTimeCount,outHeader,info);
    }
    // for completeness sake?
    virtual status_t Read(void * outBuffer, int64 * outNumerator,
                          media_header * outHeader = NULL,
                          media_decode_info * info = NULL) {
      return BExtractor::Read(this,outBuffer,outNumerator,outHeader,info);
    }
/* end read extensions functions */
    // pad me
  };
  
  // pad me
};