src/gen_proto/Scrubbytalk.pb.m

// Generated by the protocol buffer compiler.  DO NOT EDIT!

#import "Scrubbytalk.pb.h"
// @@protoc_insertion_point(imports)

@implementation ScrubbytalkRoot
static PBExtensionRegistry* extensionRegistry = nil;
+ (PBExtensionRegistry*) extensionRegistry {
  return extensionRegistry;
}

+ (void) initialize {
  if (self == [ScrubbytalkRoot class]) {
    PBMutableExtensionRegistry* registry = [PBMutableExtensionRegistry registry];
    [self registerAllExtensions:registry];
    extensionRegistry = registry;
  }
}
+ (void) registerAllExtensions:(PBMutableExtensionRegistry*) registry {
}
@end

@interface ScrubbytalkMessage ()
@property ScrubbytalkMessageMsgType msgType;
@property (strong) VideoFrameV2* videoFrameV2;
@property (strong) VideoFrameV3* videoFrameV3;
@end

@implementation ScrubbytalkMessage

- (BOOL) hasMsgType {
  return !!hasMsgType_;
}
- (void) setHasMsgType:(BOOL) value_ {
  hasMsgType_ = !!value_;
}
@synthesize msgType;
- (BOOL) hasVideoFrameV2 {
  return !!hasVideoFrameV2_;
}
- (void) setHasVideoFrameV2:(BOOL) value_ {
  hasVideoFrameV2_ = !!value_;
}
@synthesize videoFrameV2;
- (BOOL) hasVideoFrameV3 {
  return !!hasVideoFrameV3_;
}
- (void) setHasVideoFrameV3:(BOOL) value_ {
  hasVideoFrameV3_ = !!value_;
}
@synthesize videoFrameV3;
- (id) init {
  if ((self = [super init])) {
    self.msgType = ScrubbytalkMessageMsgTypeVideoFrame;
    self.videoFrameV2 = [VideoFrameV2 defaultInstance];
    self.videoFrameV3 = [VideoFrameV3 defaultInstance];
  }
  return self;
}
static ScrubbytalkMessage* defaultScrubbytalkMessageInstance = nil;
+ (void) initialize {
  if (self == [ScrubbytalkMessage class]) {
    defaultScrubbytalkMessageInstance = [[ScrubbytalkMessage alloc] init];
  }
}
+ (ScrubbytalkMessage*) defaultInstance {
  return defaultScrubbytalkMessageInstance;
}
- (ScrubbytalkMessage*) defaultInstance {
  return defaultScrubbytalkMessageInstance;
}
- (BOOL) isInitialized {
  if (!self.hasMsgType) {
    return NO;
  }
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  if (self.hasMsgType) {
    [output writeEnum:1 value:self.msgType];
  }
  if (self.hasVideoFrameV2) {
    [output writeMessage:2 value:self.videoFrameV2];
  }
  if (self.hasVideoFrameV3) {
    [output writeMessage:3 value:self.videoFrameV3];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  if (self.hasMsgType) {
    size_ += computeEnumSize(1, self.msgType);
  }
  if (self.hasVideoFrameV2) {
    size_ += computeMessageSize(2, self.videoFrameV2);
  }
  if (self.hasVideoFrameV3) {
    size_ += computeMessageSize(3, self.videoFrameV3);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (ScrubbytalkMessage*) parseFromData:(NSData*) data {
  return (ScrubbytalkMessage*)[[[ScrubbytalkMessage builder] mergeFromData:data] build];
}
+ (ScrubbytalkMessage*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ScrubbytalkMessage*)[[[ScrubbytalkMessage builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (ScrubbytalkMessage*) parseFromInputStream:(NSInputStream*) input {
  return (ScrubbytalkMessage*)[[[ScrubbytalkMessage builder] mergeFromInputStream:input] build];
}
+ (ScrubbytalkMessage*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ScrubbytalkMessage*)[[[ScrubbytalkMessage builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ScrubbytalkMessage*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (ScrubbytalkMessage*)[[[ScrubbytalkMessage builder] mergeFromCodedInputStream:input] build];
}
+ (ScrubbytalkMessage*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (ScrubbytalkMessage*)[[[ScrubbytalkMessage builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (ScrubbytalkMessageBuilder*) builder {
  return [[ScrubbytalkMessageBuilder alloc] init];
}
+ (ScrubbytalkMessageBuilder*) builderWithPrototype:(ScrubbytalkMessage*) prototype {
  return [[ScrubbytalkMessage builder] mergeFrom:prototype];
}
- (ScrubbytalkMessageBuilder*) builder {
  return [ScrubbytalkMessage builder];
}
- (ScrubbytalkMessageBuilder*) toBuilder {
  return [ScrubbytalkMessage builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  if (self.hasMsgType) {
    [output appendFormat:@"%@%@: %d\n", indent, @"msgType", self.msgType];
  }
  if (self.hasVideoFrameV2) {
    [output appendFormat:@"%@%@ {\n", indent, @"videoFrameV2"];
    [self.videoFrameV2 writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  if (self.hasVideoFrameV3) {
    [output appendFormat:@"%@%@ {\n", indent, @"videoFrameV3"];
    [self.videoFrameV3 writeDescriptionTo:output
                         withIndent:[NSString stringWithFormat:@"%@  ", indent]];
    [output appendFormat:@"%@}\n", indent];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[ScrubbytalkMessage class]]) {
    return NO;
  }
  ScrubbytalkMessage *otherMessage = other;
  return
      self.hasMsgType == otherMessage.hasMsgType &&
      (!self.hasMsgType || self.msgType == otherMessage.msgType) &&
      self.hasVideoFrameV2 == otherMessage.hasVideoFrameV2 &&
      (!self.hasVideoFrameV2 || [self.videoFrameV2 isEqual:otherMessage.videoFrameV2]) &&
      self.hasVideoFrameV3 == otherMessage.hasVideoFrameV3 &&
      (!self.hasVideoFrameV3 || [self.videoFrameV3 isEqual:otherMessage.videoFrameV3]) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  if (self.hasMsgType) {
    hashCode = hashCode * 31 + self.msgType;
  }
  if (self.hasVideoFrameV2) {
    hashCode = hashCode * 31 + [self.videoFrameV2 hash];
  }
  if (self.hasVideoFrameV3) {
    hashCode = hashCode * 31 + [self.videoFrameV3 hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

BOOL ScrubbytalkMessageMsgTypeIsValidValue(ScrubbytalkMessageMsgType value) {
  switch (value) {
    case ScrubbytalkMessageMsgTypeVideoFrame:
      return YES;
    default:
      return NO;
  }
}
@interface ScrubbytalkMessageBuilder()
@property (strong) ScrubbytalkMessage* result;
@end

@implementation ScrubbytalkMessageBuilder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[ScrubbytalkMessage alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (ScrubbytalkMessageBuilder*) clear {
  self.result = [[ScrubbytalkMessage alloc] init];
  return self;
}
- (ScrubbytalkMessageBuilder*) clone {
  return [ScrubbytalkMessage builderWithPrototype:result];
}
- (ScrubbytalkMessage*) defaultInstance {
  return [ScrubbytalkMessage defaultInstance];
}
- (ScrubbytalkMessage*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (ScrubbytalkMessage*) buildPartial {
  ScrubbytalkMessage* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (ScrubbytalkMessageBuilder*) mergeFrom:(ScrubbytalkMessage*) other {
  if (other == [ScrubbytalkMessage defaultInstance]) {
    return self;
  }
  if (other.hasMsgType) {
    [self setMsgType:other.msgType];
  }
  if (other.hasVideoFrameV2) {
    [self mergeVideoFrameV2:other.videoFrameV2];
  }
  if (other.hasVideoFrameV3) {
    [self mergeVideoFrameV3:other.videoFrameV3];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (ScrubbytalkMessageBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (ScrubbytalkMessageBuilder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 8: {
        ScrubbytalkMessageMsgType value = (ScrubbytalkMessageMsgType)[input readEnum];
        if (ScrubbytalkMessageMsgTypeIsValidValue(value)) {
          [self setMsgType:value];
        } else {
          [unknownFields mergeVarintField:1 value:value];
        }
        break;
      }
      case 18: {
        VideoFrameV2Builder* subBuilder = [VideoFrameV2 builder];
        if (self.hasVideoFrameV2) {
          [subBuilder mergeFrom:self.videoFrameV2];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setVideoFrameV2:[subBuilder buildPartial]];
        break;
      }
      case 26: {
        VideoFrameV3Builder* subBuilder = [VideoFrameV3 builder];
        if (self.hasVideoFrameV3) {
          [subBuilder mergeFrom:self.videoFrameV3];
        }
        [input readMessage:subBuilder extensionRegistry:extensionRegistry];
        [self setVideoFrameV3:[subBuilder buildPartial]];
        break;
      }
    }
  }
}
- (BOOL) hasMsgType {
  return result.hasMsgType;
}
- (ScrubbytalkMessageMsgType) msgType {
  return result.msgType;
}
- (ScrubbytalkMessageBuilder*) setMsgType:(ScrubbytalkMessageMsgType) value {
  result.hasMsgType = YES;
  result.msgType = value;
  return self;
}
- (ScrubbytalkMessageBuilder*) clearMsgType {
  result.hasMsgType = NO;
  result.msgType = ScrubbytalkMessageMsgTypeVideoFrame;
  return self;
}
- (BOOL) hasVideoFrameV2 {
  return result.hasVideoFrameV2;
}
- (VideoFrameV2*) videoFrameV2 {
  return result.videoFrameV2;
}
- (ScrubbytalkMessageBuilder*) setVideoFrameV2:(VideoFrameV2*) value {
  result.hasVideoFrameV2 = YES;
  result.videoFrameV2 = value;
  return self;
}
- (ScrubbytalkMessageBuilder*) setVideoFrameV2Builder:(VideoFrameV2Builder*) builderForValue {
  return [self setVideoFrameV2:[builderForValue build]];
}
- (ScrubbytalkMessageBuilder*) mergeVideoFrameV2:(VideoFrameV2*) value {
  if (result.hasVideoFrameV2 &&
      result.videoFrameV2 != [VideoFrameV2 defaultInstance]) {
    result.videoFrameV2 =
      [[[VideoFrameV2 builderWithPrototype:result.videoFrameV2] mergeFrom:value] buildPartial];
  } else {
    result.videoFrameV2 = value;
  }
  result.hasVideoFrameV2 = YES;
  return self;
}
- (ScrubbytalkMessageBuilder*) clearVideoFrameV2 {
  result.hasVideoFrameV2 = NO;
  result.videoFrameV2 = [VideoFrameV2 defaultInstance];
  return self;
}
- (BOOL) hasVideoFrameV3 {
  return result.hasVideoFrameV3;
}
- (VideoFrameV3*) videoFrameV3 {
  return result.videoFrameV3;
}
- (ScrubbytalkMessageBuilder*) setVideoFrameV3:(VideoFrameV3*) value {
  result.hasVideoFrameV3 = YES;
  result.videoFrameV3 = value;
  return self;
}
- (ScrubbytalkMessageBuilder*) setVideoFrameV3Builder:(VideoFrameV3Builder*) builderForValue {
  return [self setVideoFrameV3:[builderForValue build]];
}
- (ScrubbytalkMessageBuilder*) mergeVideoFrameV3:(VideoFrameV3*) value {
  if (result.hasVideoFrameV3 &&
      result.videoFrameV3 != [VideoFrameV3 defaultInstance]) {
    result.videoFrameV3 =
      [[[VideoFrameV3 builderWithPrototype:result.videoFrameV3] mergeFrom:value] buildPartial];
  } else {
    result.videoFrameV3 = value;
  }
  result.hasVideoFrameV3 = YES;
  return self;
}
- (ScrubbytalkMessageBuilder*) clearVideoFrameV3 {
  result.hasVideoFrameV3 = NO;
  result.videoFrameV3 = [VideoFrameV3 defaultInstance];
  return self;
}
@end

@interface VideoFrameV2 ()
@property (strong) NSMutableArray * nalsArray;
@property Float64 timestamp;
@property SInt64 chunkNum;
@property BOOL isCacheable;
@property BOOL isLastChunkFrame;
@end

@implementation VideoFrameV2

@synthesize nalsArray;
@dynamic nals;
- (BOOL) hasTimestamp {
  return !!hasTimestamp_;
}
- (void) setHasTimestamp:(BOOL) value_ {
  hasTimestamp_ = !!value_;
}
@synthesize timestamp;
- (BOOL) hasChunkNum {
  return !!hasChunkNum_;
}
- (void) setHasChunkNum:(BOOL) value_ {
  hasChunkNum_ = !!value_;
}
@synthesize chunkNum;
- (BOOL) hasIsCacheable {
  return !!hasIsCacheable_;
}
- (void) setHasIsCacheable:(BOOL) value_ {
  hasIsCacheable_ = !!value_;
}
- (BOOL) isCacheable {
  return !!isCacheable_;
}
- (void) setIsCacheable:(BOOL) value_ {
  isCacheable_ = !!value_;
}
- (BOOL) hasIsLastChunkFrame {
  return !!hasIsLastChunkFrame_;
}
- (void) setHasIsLastChunkFrame:(BOOL) value_ {
  hasIsLastChunkFrame_ = !!value_;
}
- (BOOL) isLastChunkFrame {
  return !!isLastChunkFrame_;
}
- (void) setIsLastChunkFrame:(BOOL) value_ {
  isLastChunkFrame_ = !!value_;
}
- (id) init {
  if ((self = [super init])) {
    self.timestamp = 0;
    self.chunkNum = 0L;
    self.isCacheable = NO;
    self.isLastChunkFrame = NO;
  }
  return self;
}
static VideoFrameV2* defaultVideoFrameV2Instance = nil;
+ (void) initialize {
  if (self == [VideoFrameV2 class]) {
    defaultVideoFrameV2Instance = [[VideoFrameV2 alloc] init];
  }
}
+ (VideoFrameV2*) defaultInstance {
  return defaultVideoFrameV2Instance;
}
- (VideoFrameV2*) defaultInstance {
  return defaultVideoFrameV2Instance;
}
- (NSArray *)nals {
  return nalsArray;
}
- (NSData*)nalsAtIndex:(NSUInteger)index {
  return [nalsArray objectAtIndex:index];
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  [self.nalsArray enumerateObjectsUsingBlock:^(NSData *element, NSUInteger idx, BOOL *stop) {
    [output writeData:1 value:element];
  }];
  if (self.hasTimestamp) {
    [output writeDouble:2 value:self.timestamp];
  }
  if (self.hasChunkNum) {
    [output writeInt64:3 value:self.chunkNum];
  }
  if (self.hasIsCacheable) {
    [output writeBool:4 value:self.isCacheable];
  }
  if (self.hasIsLastChunkFrame) {
    [output writeBool:5 value:self.isLastChunkFrame];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  {
    __block SInt32 dataSize = 0;
    const NSUInteger count = self.nalsArray.count;
    [self.nalsArray enumerateObjectsUsingBlock:^(NSData *element, NSUInteger idx, BOOL *stop) {
      dataSize += computeDataSizeNoTag(element);
    }];
    size_ += dataSize;
    size_ += (SInt32)(1 * count);
  }
  if (self.hasTimestamp) {
    size_ += computeDoubleSize(2, self.timestamp);
  }
  if (self.hasChunkNum) {
    size_ += computeInt64Size(3, self.chunkNum);
  }
  if (self.hasIsCacheable) {
    size_ += computeBoolSize(4, self.isCacheable);
  }
  if (self.hasIsLastChunkFrame) {
    size_ += computeBoolSize(5, self.isLastChunkFrame);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (VideoFrameV2*) parseFromData:(NSData*) data {
  return (VideoFrameV2*)[[[VideoFrameV2 builder] mergeFromData:data] build];
}
+ (VideoFrameV2*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (VideoFrameV2*)[[[VideoFrameV2 builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (VideoFrameV2*) parseFromInputStream:(NSInputStream*) input {
  return (VideoFrameV2*)[[[VideoFrameV2 builder] mergeFromInputStream:input] build];
}
+ (VideoFrameV2*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (VideoFrameV2*)[[[VideoFrameV2 builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (VideoFrameV2*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (VideoFrameV2*)[[[VideoFrameV2 builder] mergeFromCodedInputStream:input] build];
}
+ (VideoFrameV2*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (VideoFrameV2*)[[[VideoFrameV2 builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (VideoFrameV2Builder*) builder {
  return [[VideoFrameV2Builder alloc] init];
}
+ (VideoFrameV2Builder*) builderWithPrototype:(VideoFrameV2*) prototype {
  return [[VideoFrameV2 builder] mergeFrom:prototype];
}
- (VideoFrameV2Builder*) builder {
  return [VideoFrameV2 builder];
}
- (VideoFrameV2Builder*) toBuilder {
  return [VideoFrameV2 builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  [self.nalsArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@: %@\n", indent, @"nals", obj];
  }];
  if (self.hasTimestamp) {
    [output appendFormat:@"%@%@: %@\n", indent, @"timestamp", [NSNumber numberWithDouble:self.timestamp]];
  }
  if (self.hasChunkNum) {
    [output appendFormat:@"%@%@: %@\n", indent, @"chunkNum", [NSNumber numberWithLongLong:self.chunkNum]];
  }
  if (self.hasIsCacheable) {
    [output appendFormat:@"%@%@: %@\n", indent, @"isCacheable", [NSNumber numberWithBool:self.isCacheable]];
  }
  if (self.hasIsLastChunkFrame) {
    [output appendFormat:@"%@%@: %@\n", indent, @"isLastChunkFrame", [NSNumber numberWithBool:self.isLastChunkFrame]];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[VideoFrameV2 class]]) {
    return NO;
  }
  VideoFrameV2 *otherMessage = other;
  return
      [self.nalsArray isEqualToArray:otherMessage.nalsArray] &&
      self.hasTimestamp == otherMessage.hasTimestamp &&
      (!self.hasTimestamp || self.timestamp == otherMessage.timestamp) &&
      self.hasChunkNum == otherMessage.hasChunkNum &&
      (!self.hasChunkNum || self.chunkNum == otherMessage.chunkNum) &&
      self.hasIsCacheable == otherMessage.hasIsCacheable &&
      (!self.hasIsCacheable || self.isCacheable == otherMessage.isCacheable) &&
      self.hasIsLastChunkFrame == otherMessage.hasIsLastChunkFrame &&
      (!self.hasIsLastChunkFrame || self.isLastChunkFrame == otherMessage.isLastChunkFrame) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  [self.nalsArray enumerateObjectsUsingBlock:^(id element, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [element hash];
  }];
  if (self.hasTimestamp) {
    hashCode = hashCode * 31 + [[NSNumber numberWithDouble:self.timestamp] hash];
  }
  if (self.hasChunkNum) {
    hashCode = hashCode * 31 + [[NSNumber numberWithLongLong:self.chunkNum] hash];
  }
  if (self.hasIsCacheable) {
    hashCode = hashCode * 31 + [[NSNumber numberWithBool:self.isCacheable] hash];
  }
  if (self.hasIsLastChunkFrame) {
    hashCode = hashCode * 31 + [[NSNumber numberWithBool:self.isLastChunkFrame] hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface VideoFrameV2Builder()
@property (strong) VideoFrameV2* result;
@end

@implementation VideoFrameV2Builder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[VideoFrameV2 alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (VideoFrameV2Builder*) clear {
  self.result = [[VideoFrameV2 alloc] init];
  return self;
}
- (VideoFrameV2Builder*) clone {
  return [VideoFrameV2 builderWithPrototype:result];
}
- (VideoFrameV2*) defaultInstance {
  return [VideoFrameV2 defaultInstance];
}
- (VideoFrameV2*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (VideoFrameV2*) buildPartial {
  VideoFrameV2* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (VideoFrameV2Builder*) mergeFrom:(VideoFrameV2*) other {
  if (other == [VideoFrameV2 defaultInstance]) {
    return self;
  }
  if (other.nalsArray.count > 0) {
    if (result.nalsArray == nil) {
      result.nalsArray = [[NSMutableArray alloc] initWithArray:other.nalsArray];
    } else {
      [result.nalsArray addObjectsFromArray:other.nalsArray];
    }
  }
  if (other.hasTimestamp) {
    [self setTimestamp:other.timestamp];
  }
  if (other.hasChunkNum) {
    [self setChunkNum:other.chunkNum];
  }
  if (other.hasIsCacheable) {
    [self setIsCacheable:other.isCacheable];
  }
  if (other.hasIsLastChunkFrame) {
    [self setIsLastChunkFrame:other.isLastChunkFrame];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (VideoFrameV2Builder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (VideoFrameV2Builder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self addNals:[input readData]];
        break;
      }
      case 17: {
        [self setTimestamp:[input readDouble]];
        break;
      }
      case 24: {
        [self setChunkNum:[input readInt64]];
        break;
      }
      case 32: {
        [self setIsCacheable:[input readBool]];
        break;
      }
      case 40: {
        [self setIsLastChunkFrame:[input readBool]];
        break;
      }
    }
  }
}
- (NSMutableArray *)nals {
  return result.nalsArray;
}
- (NSData*)nalsAtIndex:(NSUInteger)index {
  return [result nalsAtIndex:index];
}
- (VideoFrameV2Builder *)addNals:(NSData*)value {
  if (result.nalsArray == nil) {
    result.nalsArray = [[NSMutableArray alloc]init];
  }
  [result.nalsArray addObject:value];
  return self;
}
- (VideoFrameV2Builder *)setNalsArray:(NSArray *)array {
  result.nalsArray = [[NSMutableArray alloc] initWithArray:array];
  return self;
}
- (VideoFrameV2Builder *)clearNals {
  result.nalsArray = nil;
  return self;
}
- (BOOL) hasTimestamp {
  return result.hasTimestamp;
}
- (Float64) timestamp {
  return result.timestamp;
}
- (VideoFrameV2Builder*) setTimestamp:(Float64) value {
  result.hasTimestamp = YES;
  result.timestamp = value;
  return self;
}
- (VideoFrameV2Builder*) clearTimestamp {
  result.hasTimestamp = NO;
  result.timestamp = 0;
  return self;
}
- (BOOL) hasChunkNum {
  return result.hasChunkNum;
}
- (SInt64) chunkNum {
  return result.chunkNum;
}
- (VideoFrameV2Builder*) setChunkNum:(SInt64) value {
  result.hasChunkNum = YES;
  result.chunkNum = value;
  return self;
}
- (VideoFrameV2Builder*) clearChunkNum {
  result.hasChunkNum = NO;
  result.chunkNum = 0L;
  return self;
}
- (BOOL) hasIsCacheable {
  return result.hasIsCacheable;
}
- (BOOL) isCacheable {
  return result.isCacheable;
}
- (VideoFrameV2Builder*) setIsCacheable:(BOOL) value {
  result.hasIsCacheable = YES;
  result.isCacheable = value;
  return self;
}
- (VideoFrameV2Builder*) clearIsCacheable {
  result.hasIsCacheable = NO;
  result.isCacheable = NO;
  return self;
}
- (BOOL) hasIsLastChunkFrame {
  return result.hasIsLastChunkFrame;
}
- (BOOL) isLastChunkFrame {
  return result.isLastChunkFrame;
}
- (VideoFrameV2Builder*) setIsLastChunkFrame:(BOOL) value {
  result.hasIsLastChunkFrame = YES;
  result.isLastChunkFrame = value;
  return self;
}
- (VideoFrameV2Builder*) clearIsLastChunkFrame {
  result.hasIsLastChunkFrame = NO;
  result.isLastChunkFrame = NO;
  return self;
}
@end

@interface VideoFrameV3 ()
@property (strong) NSMutableArray * nalsArray;
@property Float64 timestamp;
@property (strong) NSString* cacheToken;
@property Float64 chunkStartTime;
@end

@implementation VideoFrameV3

@synthesize nalsArray;
@dynamic nals;
- (BOOL) hasTimestamp {
  return !!hasTimestamp_;
}
- (void) setHasTimestamp:(BOOL) value_ {
  hasTimestamp_ = !!value_;
}
@synthesize timestamp;
- (BOOL) hasCacheToken {
  return !!hasCacheToken_;
}
- (void) setHasCacheToken:(BOOL) value_ {
  hasCacheToken_ = !!value_;
}
@synthesize cacheToken;
- (BOOL) hasChunkStartTime {
  return !!hasChunkStartTime_;
}
- (void) setHasChunkStartTime:(BOOL) value_ {
  hasChunkStartTime_ = !!value_;
}
@synthesize chunkStartTime;
- (id) init {
  if ((self = [super init])) {
    self.timestamp = 0;
    self.cacheToken = @"";
    self.chunkStartTime = 0;
  }
  return self;
}
static VideoFrameV3* defaultVideoFrameV3Instance = nil;
+ (void) initialize {
  if (self == [VideoFrameV3 class]) {
    defaultVideoFrameV3Instance = [[VideoFrameV3 alloc] init];
  }
}
+ (VideoFrameV3*) defaultInstance {
  return defaultVideoFrameV3Instance;
}
- (VideoFrameV3*) defaultInstance {
  return defaultVideoFrameV3Instance;
}
- (NSArray *)nals {
  return nalsArray;
}
- (NSData*)nalsAtIndex:(NSUInteger)index {
  return [nalsArray objectAtIndex:index];
}
- (BOOL) isInitialized {
  return YES;
}
- (void) writeToCodedOutputStream:(PBCodedOutputStream*) output {
  [self.nalsArray enumerateObjectsUsingBlock:^(NSData *element, NSUInteger idx, BOOL *stop) {
    [output writeData:1 value:element];
  }];
  if (self.hasTimestamp) {
    [output writeDouble:2 value:self.timestamp];
  }
  if (self.hasCacheToken) {
    [output writeString:3 value:self.cacheToken];
  }
  if (self.hasChunkStartTime) {
    [output writeDouble:4 value:self.chunkStartTime];
  }
  [self.unknownFields writeToCodedOutputStream:output];
}
- (SInt32) serializedSize {
  __block SInt32 size_ = memoizedSerializedSize;
  if (size_ != -1) {
    return size_;
  }

  size_ = 0;
  {
    __block SInt32 dataSize = 0;
    const NSUInteger count = self.nalsArray.count;
    [self.nalsArray enumerateObjectsUsingBlock:^(NSData *element, NSUInteger idx, BOOL *stop) {
      dataSize += computeDataSizeNoTag(element);
    }];
    size_ += dataSize;
    size_ += (SInt32)(1 * count);
  }
  if (self.hasTimestamp) {
    size_ += computeDoubleSize(2, self.timestamp);
  }
  if (self.hasCacheToken) {
    size_ += computeStringSize(3, self.cacheToken);
  }
  if (self.hasChunkStartTime) {
    size_ += computeDoubleSize(4, self.chunkStartTime);
  }
  size_ += self.unknownFields.serializedSize;
  memoizedSerializedSize = size_;
  return size_;
}
+ (VideoFrameV3*) parseFromData:(NSData*) data {
  return (VideoFrameV3*)[[[VideoFrameV3 builder] mergeFromData:data] build];
}
+ (VideoFrameV3*) parseFromData:(NSData*) data extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (VideoFrameV3*)[[[VideoFrameV3 builder] mergeFromData:data extensionRegistry:extensionRegistry] build];
}
+ (VideoFrameV3*) parseFromInputStream:(NSInputStream*) input {
  return (VideoFrameV3*)[[[VideoFrameV3 builder] mergeFromInputStream:input] build];
}
+ (VideoFrameV3*) parseFromInputStream:(NSInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (VideoFrameV3*)[[[VideoFrameV3 builder] mergeFromInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (VideoFrameV3*) parseFromCodedInputStream:(PBCodedInputStream*) input {
  return (VideoFrameV3*)[[[VideoFrameV3 builder] mergeFromCodedInputStream:input] build];
}
+ (VideoFrameV3*) parseFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  return (VideoFrameV3*)[[[VideoFrameV3 builder] mergeFromCodedInputStream:input extensionRegistry:extensionRegistry] build];
}
+ (VideoFrameV3Builder*) builder {
  return [[VideoFrameV3Builder alloc] init];
}
+ (VideoFrameV3Builder*) builderWithPrototype:(VideoFrameV3*) prototype {
  return [[VideoFrameV3 builder] mergeFrom:prototype];
}
- (VideoFrameV3Builder*) builder {
  return [VideoFrameV3 builder];
}
- (VideoFrameV3Builder*) toBuilder {
  return [VideoFrameV3 builderWithPrototype:self];
}
- (void) writeDescriptionTo:(NSMutableString*) output withIndent:(NSString*) indent {
  [self.nalsArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    [output appendFormat:@"%@%@: %@\n", indent, @"nals", obj];
  }];
  if (self.hasTimestamp) {
    [output appendFormat:@"%@%@: %@\n", indent, @"timestamp", [NSNumber numberWithDouble:self.timestamp]];
  }
  if (self.hasCacheToken) {
    [output appendFormat:@"%@%@: %@\n", indent, @"cacheToken", self.cacheToken];
  }
  if (self.hasChunkStartTime) {
    [output appendFormat:@"%@%@: %@\n", indent, @"chunkStartTime", [NSNumber numberWithDouble:self.chunkStartTime]];
  }
  [self.unknownFields writeDescriptionTo:output withIndent:indent];
}
- (BOOL) isEqual:(id)other {
  if (other == self) {
    return YES;
  }
  if (![other isKindOfClass:[VideoFrameV3 class]]) {
    return NO;
  }
  VideoFrameV3 *otherMessage = other;
  return
      [self.nalsArray isEqualToArray:otherMessage.nalsArray] &&
      self.hasTimestamp == otherMessage.hasTimestamp &&
      (!self.hasTimestamp || self.timestamp == otherMessage.timestamp) &&
      self.hasCacheToken == otherMessage.hasCacheToken &&
      (!self.hasCacheToken || [self.cacheToken isEqual:otherMessage.cacheToken]) &&
      self.hasChunkStartTime == otherMessage.hasChunkStartTime &&
      (!self.hasChunkStartTime || self.chunkStartTime == otherMessage.chunkStartTime) &&
      (self.unknownFields == otherMessage.unknownFields || (self.unknownFields != nil && [self.unknownFields isEqual:otherMessage.unknownFields]));
}
- (NSUInteger) hash {
  __block NSUInteger hashCode = 7;
  [self.nalsArray enumerateObjectsUsingBlock:^(id element, NSUInteger idx, BOOL *stop) {
    hashCode = hashCode * 31 + [element hash];
  }];
  if (self.hasTimestamp) {
    hashCode = hashCode * 31 + [[NSNumber numberWithDouble:self.timestamp] hash];
  }
  if (self.hasCacheToken) {
    hashCode = hashCode * 31 + [self.cacheToken hash];
  }
  if (self.hasChunkStartTime) {
    hashCode = hashCode * 31 + [[NSNumber numberWithDouble:self.chunkStartTime] hash];
  }
  hashCode = hashCode * 31 + [self.unknownFields hash];
  return hashCode;
}
@end

@interface VideoFrameV3Builder()
@property (strong) VideoFrameV3* result;
@end

@implementation VideoFrameV3Builder
@synthesize result;
- (id) init {
  if ((self = [super init])) {
    self.result = [[VideoFrameV3 alloc] init];
  }
  return self;
}
- (PBGeneratedMessage*) internalGetResult {
  return result;
}
- (VideoFrameV3Builder*) clear {
  self.result = [[VideoFrameV3 alloc] init];
  return self;
}
- (VideoFrameV3Builder*) clone {
  return [VideoFrameV3 builderWithPrototype:result];
}
- (VideoFrameV3*) defaultInstance {
  return [VideoFrameV3 defaultInstance];
}
- (VideoFrameV3*) build {
  [self checkInitialized];
  return [self buildPartial];
}
- (VideoFrameV3*) buildPartial {
  VideoFrameV3* returnMe = result;
  self.result = nil;
  return returnMe;
}
- (VideoFrameV3Builder*) mergeFrom:(VideoFrameV3*) other {
  if (other == [VideoFrameV3 defaultInstance]) {
    return self;
  }
  if (other.nalsArray.count > 0) {
    if (result.nalsArray == nil) {
      result.nalsArray = [[NSMutableArray alloc] initWithArray:other.nalsArray];
    } else {
      [result.nalsArray addObjectsFromArray:other.nalsArray];
    }
  }
  if (other.hasTimestamp) {
    [self setTimestamp:other.timestamp];
  }
  if (other.hasCacheToken) {
    [self setCacheToken:other.cacheToken];
  }
  if (other.hasChunkStartTime) {
    [self setChunkStartTime:other.chunkStartTime];
  }
  [self mergeUnknownFields:other.unknownFields];
  return self;
}
- (VideoFrameV3Builder*) mergeFromCodedInputStream:(PBCodedInputStream*) input {
  return [self mergeFromCodedInputStream:input extensionRegistry:[PBExtensionRegistry emptyRegistry]];
}
- (VideoFrameV3Builder*) mergeFromCodedInputStream:(PBCodedInputStream*) input extensionRegistry:(PBExtensionRegistry*) extensionRegistry {
  PBUnknownFieldSetBuilder* unknownFields = [PBUnknownFieldSet builderWithUnknownFields:self.unknownFields];
  while (YES) {
    SInt32 tag = [input readTag];
    switch (tag) {
      case 0:
        [self setUnknownFields:[unknownFields build]];
        return self;
      default: {
        if (![self parseUnknownField:input unknownFields:unknownFields extensionRegistry:extensionRegistry tag:tag]) {
          [self setUnknownFields:[unknownFields build]];
          return self;
        }
        break;
      }
      case 10: {
        [self addNals:[input readData]];
        break;
      }
      case 17: {
        [self setTimestamp:[input readDouble]];
        break;
      }
      case 26: {
        [self setCacheToken:[input readString]];
        break;
      }
      case 33: {
        [self setChunkStartTime:[input readDouble]];
        break;
      }
    }
  }
}
- (NSMutableArray *)nals {
  return result.nalsArray;
}
- (NSData*)nalsAtIndex:(NSUInteger)index {
  return [result nalsAtIndex:index];
}
- (VideoFrameV3Builder *)addNals:(NSData*)value {
  if (result.nalsArray == nil) {
    result.nalsArray = [[NSMutableArray alloc]init];
  }
  [result.nalsArray addObject:value];
  return self;
}
- (VideoFrameV3Builder *)setNalsArray:(NSArray *)array {
  result.nalsArray = [[NSMutableArray alloc] initWithArray:array];
  return self;
}
- (VideoFrameV3Builder *)clearNals {
  result.nalsArray = nil;
  return self;
}
- (BOOL) hasTimestamp {
  return result.hasTimestamp;
}
- (Float64) timestamp {
  return result.timestamp;
}
- (VideoFrameV3Builder*) setTimestamp:(Float64) value {
  result.hasTimestamp = YES;
  result.timestamp = value;
  return self;
}
- (VideoFrameV3Builder*) clearTimestamp {
  result.hasTimestamp = NO;
  result.timestamp = 0;
  return self;
}
- (BOOL) hasCacheToken {
  return result.hasCacheToken;
}
- (NSString*) cacheToken {
  return result.cacheToken;
}
- (VideoFrameV3Builder*) setCacheToken:(NSString*) value {
  result.hasCacheToken = YES;
  result.cacheToken = value;
  return self;
}
- (VideoFrameV3Builder*) clearCacheToken {
  result.hasCacheToken = NO;
  result.cacheToken = @"";
  return self;
}
- (BOOL) hasChunkStartTime {
  return result.hasChunkStartTime;
}
- (Float64) chunkStartTime {
  return result.chunkStartTime;
}
- (VideoFrameV3Builder*) setChunkStartTime:(Float64) value {
  result.hasChunkStartTime = YES;
  result.chunkStartTime = value;
  return self;
}
- (VideoFrameV3Builder*) clearChunkStartTime {
  result.hasChunkStartTime = NO;
  result.chunkStartTime = 0;
  return self;
}
@end


// @@protoc_insertion_point(global_scope)