webm_parser.h

// Copyright 2014 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 PACKAGER_MEDIA_FORMATS_WEBM_WEBM_PARSER_H_
#define PACKAGER_MEDIA_FORMATS_WEBM_WEBM_PARSER_H_
 
#include <stdint.h>
 
#include <string>
#include <vector>
 
#include "packager/base/macros.h"
 
namespace shaka {
namespace media {
 
class WebMParserClient {
 public:
  virtual ~WebMParserClient();
 
  virtual WebMParserClient* OnListStart(int id);
  virtual bool OnListEnd(int id);
  virtual bool OnUInt(int id, int64_t val);
  virtual bool OnFloat(int id, double val);
  virtual bool OnBinary(int id, const uint8_t* data, int size);
  virtual bool OnString(int id, const std::string& str);
 
 protected:
  WebMParserClient();
 
  DISALLOW_COPY_AND_ASSIGN(WebMParserClient);
};
 
struct ListElementInfo;
 
class WebMListParser {
 public:
  WebMListParser(int id, WebMParserClient* client);
  ~WebMListParser();
 
  void Reset();
 
  int Parse(const uint8_t* buf, int size);
 
  bool IsParsingComplete() const;
 
 private:
  enum State {
    NEED_LIST_HEADER,
    INSIDE_LIST,
    DONE_PARSING_LIST,
    PARSE_ERROR,
  };
 
  struct ListState {
    int id_;
    int64_t size_;
    int64_t bytes_parsed_;
    const ListElementInfo* element_info_;
    WebMParserClient* client_;
  };
 
  void ChangeState(State new_state);
 
  // Parses a single element in the current list.
  //
  // |header_size| - The size of the element header
  // |id| - The ID of the element being parsed.
  // |element_size| - The size of the element body.
  // |data| - Pointer to the element contents.
  // |size| - Number of bytes in |data|
  // |client| - Client to pass the parsed data to.
  //
  // Returns < 0 if the parse fails.
  // Returns 0 if more data is needed.
  // Returning > 0 indicates success & the number of bytes parsed.
  int ParseListElement(int header_size,
                       int id,
                       int64_t element_size,
                       const uint8_t* data,
                       int size);
 
  // Called when starting to parse a new list.
  //
  // |id| - The ID of the new list.
  // |size| - The size of the new list.
  // |client| - The client object to notify that a new list is being parsed.
  //
  // Returns true if this list can be started in the current context. False
  // if starting this list causes some sort of parse error.
  bool OnListStart(int id, int64_t size);
 
  // Called when the end of the current list has been reached. This may also
  // signal the end of the current list's ancestors if the current list happens
  // to be at the end of its parent.
  //
  // Returns true if no errors occurred while ending this list(s).
  bool OnListEnd();
 
  // Checks to see if |id_b| is a sibling or ancestor of |id_a|.
  bool IsSiblingOrAncestor(int id_a, int id_b) const;
 
  State state_;
 
  // Element ID passed to the constructor.
  const int root_id_;
 
  // Element level for |root_id_|. Used to verify that elements appear at
  // the correct level.
  const int root_level_;
 
  // WebMParserClient to handle the root list.
  WebMParserClient* const root_client_;
 
  // Stack of state for all the lists currently being parsed. Lists are
  // added and removed from this stack as they are parsed.
  std::vector<ListState> list_state_stack_;
 
  DISALLOW_COPY_AND_ASSIGN(WebMListParser);
};
 
int WebMParseElementHeader(const uint8_t* buf,
                           int size,
                           int* id,
                           int64_t* element_size);
 
}  // namespace media
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_FORMATS_WEBM_WEBM_PARSER_H_