stream_parser_samsung.h

Go to the documentation of this file.

// Copyright 2013 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.

#ifndef PPAPI_CPP_SAMSUNG_STREAM_PARSER_SAMSUNG_H_
#define PPAPI_CPP_SAMSUNG_STREAM_PARSER_SAMSUNG_H_

#include <vector>

#include "ppapi/cpp/instance.h"
#include "ppapi/cpp/var.h"
#include "ppapi/cpp/dev/buffer_dev.h"
#include "ppapi/c/samsung/pp_media_common_samsung.h"
#include "ppapi/c/samsung/pp_stream_parser_samsung.h"

namespace pp {

class CompletionCallback;
class InstanceHandle;

// Interface allowing NaCl applicaton to implement its own stream demuxer
class StreamParser_Samsung {
 public:
  // Creates StreamParser_Samsung associated with given |instance|
  explicit StreamParser_Samsung(Instance* instance);

  // Destructor
  virtual ~StreamParser_Samsung() {}

  // PPB_StreamParser_Samsung API

  // Used for registering stream parser in Browser. |type| is a MIME type
  // of stream, to witch parser be registered.
  int32_t RegisterParser(const char* type, const CompletionCallback& callback);

  // Indicates completion of parser initialization. |stream_id| is an id of
  // the stream, that Browser request to parse, if browser request parsing more
  // that one stream of that type, it allows to recognize that stream.
  // |init_status| a status of initialization.
  // If initializations is successful, the |duration| contains stream duration
  // (in microseconds) if it's possible to recognize it.
  int32_t InitSegmentReceived(int32_t stream_id, PP_Parser_InitStatus,
      PP_MicrosecondsDelta duration, const CompletionCallback& callback);

  // Indicates when new audio configuration have been parsed,
  // |config| a configuration structure
  // It's not allowed to deliver new configuration between NewMediaSegment and
  // EndOfSegment.
  int32_t NewAudioConfig(int32_t stream_id, const PP_SP_AudioDecoderConfig&,
      const CompletionCallback& callback);

  // Indicates when new video configuration have been parsed,
  // |config| a configuration struct
  int32_t NewVideoConfig(int32_t stream_id, const PP_SP_VideoDecoderConfig&,
      const CompletionCallback& callback);

  // To deliver parsed sample one of below NewBuffers method could be used.
  // NewBuffers is allowed only between NewMediaSegment and EndOfSegment.
  // There are four variants of this method, differ used arguments.
  // For all common are:
  // |type| indicates type of track, it's enum defined in
  // pp_stream_parser_samsung.h,
  // |track_id| it's id of track, useful if is more that one track of that type
  // |buffer| a buffer with stream data
  //
  // Additionally they require:
  // - passing sample information by using |samples_count| and |samples| (an
  // array with samples description, or as a |samples| vector.
  //
  // Optionally two of them allows to passing encryption information as a pair
  // of key_id and initialization vector (iv), by passing appropriate arrays
  // and its sizes or as a vectors.
protected:
  int32_t NewBuffers(int32_t stream_id,
      PP_ElementaryStream_Type_Samsung type,
      int32_t track_id, PP_Resource buffer,
      uint16_t key_id_size, const uint8_t key_id[],
      uint8_t iv_size, const uint8_t iv[],
      uint32_t samples_count, const PP_Sample samples[],
      const CompletionCallback& callback);
public:
  int32_t NewBuffers(int32_t stream_id,
      PP_ElementaryStream_Type_Samsung type,
      int32_t track_id, PP_Resource buffer,
      const std::vector<uint8_t>& key_id, const std::vector<uint8_t>& iv,
      const std::vector<PP_Sample>& samples,
      const CompletionCallback& callback);
  int32_t NewBuffers(int32_t stream_id,
      PP_ElementaryStream_Type_Samsung type,
      int32_t track_id, PP_Resource buffer,
      uint32_t samples_count, const PP_Sample samples[],
      const CompletionCallback& callback);
  int32_t NewBuffers(int32_t stream_id,
      PP_ElementaryStream_Type_Samsung type,
      int32_t track_id, PP_Resource buffer,
      const std::vector<PP_Sample>& samples,
      const CompletionCallback& callback);

  // Signals the beginning od a new media segment, |timestamp| the earliest
  // timestamp of all the samples in the segment
  void NewMediaSegment(int32_t stream_id, PP_MicrosecondsDelta timestamp);

  // Signals end of segment for given |stream_id|
  void EndOfSegment(int32_t stream_id);

  // Method to signal ending of |Parse| from PPP interface (for current buffer).
  void ParseFinished(int32_t stream_id, PP_ParseResult result);

  // A new potentially encrypted stream has been parsed. |type| describes type
  // of the initialization data |init_data| associated with the stream.
  int32_t NeedKey(int32_t stream_id, const Var& type,
      uint32_t init_data_size, uint8_t* init_data,
      const CompletionCallback& callback);

  // PPP_StreamParser_Samsung API

  // Initialize the parser. Must be called before any data is passed to Parse().
  // |stream_type| describe type of stream to parse (should be one of type,
  // passed in PPB RegisterParser). |stream_id| it's a id of stream to parse.
  virtual bool Init(int32_t stream_id) = 0;

  // Called when a seek occurs. This flushes the current parser state and puts
  // the parser in a state where it can receive data for the new seek point.
  virtual void Flush(int32_t stream_id) = 0;

  // Called when there is new data to parse. |data| contains stream to parse.
  //
  // Return PP_OK if the parse succeds
  virtual bool Parse(int32_t stream_id, Buffer_Dev data) = 0;

  // Called when a parser must be "closed". Used for flushes the current parser
  // state, and configs.
  virtual void Close(int32_t stream_id) = 0;

 private:
  Instance* instance_;
};

}  // namespace pp

#endif  // PPAPI_CPP_SAMSUNG_STREAM_PARSER_SAMSUNG_H_