ppb_stream_parser_samsung.h

Go to the documentation of this file.

/* Copyright (c) 2015 Samsung Electronics. All rights reserved.
 */

/* From samsung/ppb_stream_parser_samsung.idl,
 *   modified Mon Jun 22 14:26:33 2015.
 */

#ifndef PPAPI_C_SAMSUNG_PPB_STREAM_PARSER_SAMSUNG_H_
#define PPAPI_C_SAMSUNG_PPB_STREAM_PARSER_SAMSUNG_H_

#include "ppapi/c/pp_bool.h"
#include "ppapi/c/pp_completion_callback.h"
#include "ppapi/c/pp_instance.h"
#include "ppapi/c/pp_macros.h"
#include "ppapi/c/pp_resource.h"
#include "ppapi/c/pp_stdint.h"
#include "ppapi/c/pp_var.h"
#include "ppapi/c/samsung/pp_media_codecs_samsung.h"
#include "ppapi/c/samsung/pp_media_common_samsung.h"
#include "ppapi/c/samsung/pp_stream_parser_samsung.h"
#include "ppapi/c/samsung/ppp_stream_parser_samsung.h"

#define PPB_STREAMPARSER_SAMSUNG_INTERFACE_0_9 "PPB_StreamParser_Samsung;0.9"
#define PPB_STREAMPARSER_SAMSUNG_INTERFACE_0_10 "PPB_StreamParser_Samsung;0.10"
#define PPB_STREAMPARSER_SAMSUNG_INTERFACE \
    PPB_STREAMPARSER_SAMSUNG_INTERFACE_0_10

/**
 * @file
 *
 * This file defines the <code>PPB_StreamParser_Samsung</code> interface.
 */


/**
 * @addtogroup Interfaces
 * @{
 */
/*
 * This interface is part of framework, used to parse media data stream.
 * Multimedia pipeline supports Media Source Extensions (MSE) for JS which
 * deliver limited set of supported media containers / container formats
 * (usually streaming media).
 * Thanks to this interface it's possible to register custom parser to extend
 * the set of build in which could be used to parse data stream and deliver
 * result to multimedia pipeline for unusual or unsupported formats.
 * Typical scenario:
 * 1. registering parser (by MimeType).
 * 2. waiting for request to initialize parser - it starts parsing procedure.
 * 3. waiting for request to parse - delivers data to parse.
 * 4. serve a result of stream parsing or error message if error occurs, handle
 *    flush/close requests if occurs.
 *
 * As a result of Parsing, parser should deliver audio/video configuration,
 * buffers with frames / samples data, and optionally encryption information
 * (used to decrypting encrypted streams). There are valid bellow sequences:
 * - Call Init (API v0.9) or InitSegmentReceived (API v0.10) as a result of
 * parse request.
 * - Delivering audio/video configuration after call Init/InitSegmentReceived
 * and not between NewSegment/EndOfSegment calls.
 * - Delivering NewBuffers only between NewSegment/EndOfSegment calls.
 */
struct PPB_StreamParser_Samsung_0_10 {
  /*
   * Method used for registering stream parser in Browser. |stream_type| is
   * a MIME type of stream, to witch parser be registered.
   * |stream_parser_interface| is a PPP interface which stream parser (user
   * NaCl application) delivering to browser to handle parsing process.
   * |user_data| The user data to be passed to the PPP functions.
   * This is optional and is typically used to help track state in case of
   * multiple parsers.
   * (see ppp_stream_parser_samsung.h for details).
   */
  int32_t (*RegisterParser)(
      PP_Instance instance,
      struct PP_Var stream_type,
      const struct PPP_StreamParser_Samsung_0_9* stream_parser_interface,
      struct PP_CompletionCallback callback,
      void* user_data);
  /*
   * 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.
   * Equivalent for API v0.9 is |Init| method, which return status (|result|)
   * as PP_OK, or PP_FALSE if an error occurred.
   */
  int32_t (*InitSegmentReceived)(PP_Instance instance,
                                 int32_t stream_id,
                                 PP_Parser_InitStatus init_status,
                                 PP_MicrosecondsDelta duration,
                                 struct PP_CompletionCallback callback);
  /*
   * Indicates when new audio configuration have been parsed,
   * |config| it's a configuration structure.
   */
  int32_t (*NewAudioConfig)(PP_Instance instance,
                            int32_t stream_id,
                            const struct PP_SP_AudioDecoderConfig* config,
                            struct PP_CompletionCallback callback);
  /*
   * Indicates when new video configuration have been parsed,
   * |config| it's a configuration structure.
   */
  int32_t (*NewVideoConfig)(PP_Instance instance,
                            int32_t stream_id,
                            const struct PP_SP_VideoDecoderConfig* config,
                            struct PP_CompletionCallback callback);
  /*
   * New stream buffers have been parsed, |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. Frames data are send by
   * buffer. |buffer| size must be of at least sum of all frames |size|.
   * |key_id| |key_id_size| |iv| and |iv_size| - describes global id of key and
   * initialization vector used to decrypting the blocks. Global means that this
   * pair key_id / iv is common for all samples from this buffer. Global
   * pair has lower priority than individual (per sample) pair passed by
   * |PP_Sample|.
   * |samples| a array of |PP_Sample| that contain |samples_count| structures
   * of |PP_Sample| that contains information like sample data size, flags
   * used to describe sample, individual key id / initialization vector and
   * other data required to decryption encrypted sample, decode timestamp,
   * duration etc. (for details see pp_stream_parser_samsung.h : PP_Sample).
   * If sample isn't encrypted related individual key_id / iv are
   * ignored, and should be empty (NULL pointer with size set to zero).
   * If any sample in buffer isn't encrypted also global key id / iv should be
   * empty.
   * (for details see pp_stream_parser_samsung.h : PP_Sample structure).
   */
  int32_t (*NewBuffers)(PP_Instance instance,
                        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 struct PP_Sample samples[],
                        struct PP_CompletionCallback callback);
  /*
   * Signals the beginning od a new media segment, |timestamp| the earliest
   * timestamp of all the frames / samples in the segment.
   */
  void (*NewMediaSegment)(PP_Instance instance,
                          int32_t stream_id,
                          PP_MicrosecondsDelta timestamp);
  /*
   * Signals end of the segment.
   */
  void (*EndOfSegment)(PP_Instance instance, int32_t stream_id);
  /*
   * Method used to signal ending of |parse| for current buffer.
   */
  void (*ParseFinished)(PP_Instance instance,
                        int32_t stream_id,
                        PP_ParseResult result);
  /*
   * A new potentialy encrypted stream has been parsed. |type| describes type
   * of the initialization data |init_data| associated with the stream.
   */
  int32_t (*NeedKey)(PP_Instance instance,
                     int32_t stream_id,
                     struct PP_Var type,
                     struct PP_Var init_data,
                     struct PP_CompletionCallback callback);
};

typedef struct PPB_StreamParser_Samsung_0_10 PPB_StreamParser_Samsung;

struct PPB_StreamParser_Samsung_0_9 {
  PP_Bool (*RegisterParser)(
      PP_Instance instance,
      struct PP_Var stream_type,
      const struct PPP_StreamParser_Samsung_0_9* stream_parser_interface,
      void* user_data);
  PP_Bool (*Init)(PP_Instance instance,
                  int32_t stream_id,
                  PP_Bool result,
                  PP_MicrosecondsDelta duration);
  PP_Bool (*NewAudioConfig)(
      PP_Instance instance,
      int32_t stream_id,
      const struct PP_SP_AudioDecoderConfig_0_9* config);
  PP_Bool (*NewVideoConfig)(
      PP_Instance instance,
      int32_t stream_id,
      const struct PP_SP_VideoDecoderConfig_0_9* config);
  PP_Bool (*NewBuffers)(PP_Instance instance,
                        int32_t stream_id,
                        PP_ElementaryStream_Type_Samsung type,
                        int32_t track_id,
                        PP_Resource buffer,
                        uint32_t frames_count,
                        const struct PP_Frames frames[]);
  void (*NewMediaSegment)(PP_Instance instance,
                          int32_t stream_id,
                          PP_MicrosecondsDelta timestamp);
  void (*EndOfSegment)(PP_Instance instance, int32_t stream_id);
  PP_Bool (*NeedKey)(PP_Instance instance,
                     int32_t stream_id,
                     struct PP_Var type,
                     struct PP_Var init_data);
};
/**
 * @}
 */

#endif  /* PPAPI_C_SAMSUNG_PPB_STREAM_PARSER_SAMSUNG_H_ */