Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright  2010 Mozilla Foundation
      3  *
      4  * This program is made available under an ISC-style license.  See the
      5  * accompanying file LICENSE for details.
      6  */
      7 #include <assert.h>
      8 #include <stdlib.h>
      9 #include <string.h>
     10 
     11 #include "nestegg/halloc/halloc.h"
     12 #include "nestegg/include/nestegg/nestegg.h"
     13 
     14 /* EBML Elements */
     15 #define ID_EBML                 0x1a45dfa3
     16 #define ID_EBML_VERSION         0x4286
     17 #define ID_EBML_READ_VERSION    0x42f7
     18 #define ID_EBML_MAX_ID_LENGTH   0x42f2
     19 #define ID_EBML_MAX_SIZE_LENGTH 0x42f3
     20 #define ID_DOCTYPE              0x4282
     21 #define ID_DOCTYPE_VERSION      0x4287
     22 #define ID_DOCTYPE_READ_VERSION 0x4285
     23 
     24 /* Global Elements */
     25 #define ID_VOID                 0xec
     26 #define ID_CRC32                0xbf
     27 
     28 /* WebMedia Elements */
     29 #define ID_SEGMENT              0x18538067
     30 
     31 /* Seek Head Elements */
     32 #define ID_SEEK_HEAD            0x114d9b74
     33 #define ID_SEEK                 0x4dbb
     34 #define ID_SEEK_ID              0x53ab
     35 #define ID_SEEK_POSITION        0x53ac
     36 
     37 /* Info Elements */
     38 #define ID_INFO                 0x1549a966
     39 #define ID_TIMECODE_SCALE       0x2ad7b1
     40 #define ID_DURATION             0x4489
     41 
     42 /* Cluster Elements */
     43 #define ID_CLUSTER              0x1f43b675
     44 #define ID_TIMECODE             0xe7
     45 #define ID_BLOCK_GROUP          0xa0
     46 #define ID_SIMPLE_BLOCK         0xa3
     47 
     48 /* BlockGroup Elements */
     49 #define ID_BLOCK                0xa1
     50 #define ID_BLOCK_DURATION       0x9b
     51 #define ID_REFERENCE_BLOCK      0xfb
     52 
     53 /* Tracks Elements */
     54 #define ID_TRACKS               0x1654ae6b
     55 #define ID_TRACK_ENTRY          0xae
     56 #define ID_TRACK_NUMBER         0xd7
     57 #define ID_TRACK_UID            0x73c5
     58 #define ID_TRACK_TYPE           0x83
     59 #define ID_FLAG_ENABLED         0xb9
     60 #define ID_FLAG_DEFAULT         0x88
     61 #define ID_FLAG_LACING          0x9c
     62 #define ID_TRACK_TIMECODE_SCALE 0x23314f
     63 #define ID_LANGUAGE             0x22b59c
     64 #define ID_CODEC_ID             0x86
     65 #define ID_CODEC_PRIVATE        0x63a2
     66 
     67 /* Video Elements */
     68 #define ID_VIDEO                0xe0
     69 #define ID_PIXEL_WIDTH          0xb0
     70 #define ID_PIXEL_HEIGHT         0xba
     71 #define ID_PIXEL_CROP_BOTTOM    0x54aa
     72 #define ID_PIXEL_CROP_TOP       0x54bb
     73 #define ID_PIXEL_CROP_LEFT      0x54cc
     74 #define ID_PIXEL_CROP_RIGHT     0x54dd
     75 #define ID_DISPLAY_WIDTH        0x54b0
     76 #define ID_DISPLAY_HEIGHT       0x54ba
     77 
     78 /* Audio Elements */
     79 #define ID_AUDIO                0xe1
     80 #define ID_SAMPLING_FREQUENCY   0xb5
     81 #define ID_CHANNELS             0x9f
     82 #define ID_BIT_DEPTH            0x6264
     83 
     84 /* Cues Elements */
     85 #define ID_CUES                 0x1c53bb6b
     86 #define ID_CUE_POINT            0xbb
     87 #define ID_CUE_TIME             0xb3
     88 #define ID_CUE_TRACK_POSITIONS  0xb7
     89 #define ID_CUE_TRACK            0xf7
     90 #define ID_CUE_CLUSTER_POSITION 0xf1
     91 #define ID_CUE_BLOCK_NUMBER     0x5378
     92 
     93 /* EBML Types */
     94 enum ebml_type_enum {
     95   TYPE_UNKNOWN,
     96   TYPE_MASTER,
     97   TYPE_UINT,
     98   TYPE_FLOAT,
     99   TYPE_INT,
    100   TYPE_STRING,
    101   TYPE_BINARY
    102 };
    103 
    104 #define LIMIT_STRING            (1 << 20)
    105 #define LIMIT_BINARY            (1 << 24)
    106 #define LIMIT_BLOCK             (1 << 30)
    107 #define LIMIT_FRAME             (1 << 28)
    108 
    109 /* Field Flags */
    110 #define DESC_FLAG_NONE          0
    111 #define DESC_FLAG_MULTI         (1 << 0)
    112 #define DESC_FLAG_SUSPEND       (1 << 1)
    113 #define DESC_FLAG_OFFSET        (1 << 2)
    114 
    115 /* Block Header Flags */
    116 #define BLOCK_FLAGS_LACING      6
    117 
    118 /* Lacing Constants */
    119 #define LACING_NONE             0
    120 #define LACING_XIPH             1
    121 #define LACING_FIXED            2
    122 #define LACING_EBML             3
    123 
    124 /* Track Types */
    125 #define TRACK_TYPE_VIDEO        1
    126 #define TRACK_TYPE_AUDIO        2
    127 
    128 /* Track IDs */
    129 #define TRACK_ID_VP8            "V_VP8"
    130 #define TRACK_ID_VORBIS         "A_VORBIS"
    131 
    132 enum vint_mask {
    133   MASK_NONE,
    134   MASK_FIRST_BIT
    135 };
    136 
    137 struct ebml_binary {
    138   unsigned char * data;
    139   size_t length;
    140 };
    141 
    142 struct ebml_list_node {
    143   struct ebml_list_node * next;
    144   uint64_t id;
    145   void * data;
    146 };
    147 
    148 struct ebml_list {
    149   struct ebml_list_node * head;
    150   struct ebml_list_node * tail;
    151 };
    152 
    153 struct ebml_type {
    154   union ebml_value {
    155     uint64_t u;
    156     double f;
    157     int64_t i;
    158     char * s;
    159     struct ebml_binary b;
    160   } v;
    161   enum ebml_type_enum type;
    162   int read;
    163 };
    164 
    165 /* EBML Definitions */
    166 struct ebml {
    167   struct ebml_type ebml_version;
    168   struct ebml_type ebml_read_version;
    169   struct ebml_type ebml_max_id_length;
    170   struct ebml_type ebml_max_size_length;
    171   struct ebml_type doctype;
    172   struct ebml_type doctype_version;
    173   struct ebml_type doctype_read_version;
    174 };
    175 
    176 /* Matroksa Definitions */
    177 struct seek {
    178   struct ebml_type id;
    179   struct ebml_type position;
    180 };
    181 
    182 struct seek_head {
    183   struct ebml_list seek;
    184 };
    185 
    186 struct info {
    187   struct ebml_type timecode_scale;
    188   struct ebml_type duration;
    189 };
    190 
    191 struct block_group {
    192   struct ebml_type duration;
    193   struct ebml_type reference_block;
    194 };
    195 
    196 struct cluster {
    197   struct ebml_type timecode;
    198   struct ebml_list block_group;
    199 };
    200 
    201 struct video {
    202   struct ebml_type pixel_width;
    203   struct ebml_type pixel_height;
    204   struct ebml_type pixel_crop_bottom;
    205   struct ebml_type pixel_crop_top;
    206   struct ebml_type pixel_crop_left;
    207   struct ebml_type pixel_crop_right;
    208   struct ebml_type display_width;
    209   struct ebml_type display_height;
    210 };
    211 
    212 struct audio {
    213   struct ebml_type sampling_frequency;
    214   struct ebml_type channels;
    215   struct ebml_type bit_depth;
    216 };
    217 
    218 struct track_entry {
    219   struct ebml_type number;
    220   struct ebml_type uid;
    221   struct ebml_type type;
    222   struct ebml_type flag_enabled;
    223   struct ebml_type flag_default;
    224   struct ebml_type flag_lacing;
    225   struct ebml_type track_timecode_scale;
    226   struct ebml_type language;
    227   struct ebml_type codec_id;
    228   struct ebml_type codec_private;
    229   struct video video;
    230   struct audio audio;
    231 };
    232 
    233 struct tracks {
    234   struct ebml_list track_entry;
    235 };
    236 
    237 struct cue_track_positions {
    238   struct ebml_type track;
    239   struct ebml_type cluster_position;
    240   struct ebml_type block_number;
    241 };
    242 
    243 struct cue_point {
    244   struct ebml_type time;
    245   struct ebml_list cue_track_positions;
    246 };
    247 
    248 struct cues {
    249   struct ebml_list cue_point;
    250 };
    251 
    252 struct segment {
    253   struct ebml_list seek_head;
    254   struct info info;
    255   struct ebml_list cluster;
    256   struct tracks tracks;
    257   struct cues cues;
    258 };
    259 
    260 /* Misc. */
    261 struct pool_ctx {
    262   char dummy;
    263 };
    264 
    265 struct list_node {
    266   struct list_node * previous;
    267   struct ebml_element_desc * node;
    268   unsigned char * data;
    269 };
    270 
    271 struct saved_state {
    272   int64_t stream_offset;
    273   struct list_node * ancestor;
    274   uint64_t last_id;
    275   uint64_t last_size;
    276 };
    277 
    278 struct frame {
    279   unsigned char * data;
    280   size_t length;
    281   struct frame * next;
    282 };
    283 
    284 /* Public (opaque) Structures */
    285 struct nestegg {
    286   nestegg_io * io;
    287   nestegg_log log;
    288   struct pool_ctx * alloc_pool;
    289   uint64_t last_id;
    290   uint64_t last_size;
    291   struct list_node * ancestor;
    292   struct ebml ebml;
    293   struct segment segment;
    294   int64_t segment_offset;
    295   unsigned int track_count;
    296 };
    297 
    298 struct nestegg_packet {
    299   uint64_t track;
    300   uint64_t timecode;
    301   struct frame * frame;
    302 };
    303 
    304 /* Element Descriptor */
    305 struct ebml_element_desc {
    306   char const * name;
    307   uint64_t id;
    308   enum ebml_type_enum type;
    309   size_t offset;
    310   unsigned int flags;
    311   struct ebml_element_desc * children;
    312   size_t size;
    313   size_t data_offset;
    314 };
    315 
    316 #define E_FIELD(ID, TYPE, STRUCT, FIELD) \
    317   { #ID, ID, TYPE, offsetof(STRUCT, FIELD), DESC_FLAG_NONE, NULL, 0, 0 }
    318 #define E_MASTER(ID, TYPE, STRUCT, FIELD) \
    319   { #ID, ID, TYPE, offsetof(STRUCT, FIELD), DESC_FLAG_MULTI, ne_ ## FIELD ## _elements, \
    320       sizeof(struct FIELD), 0 }
    321 #define E_SINGLE_MASTER_O(ID, TYPE, STRUCT, FIELD) \
    322   { #ID, ID, TYPE, offsetof(STRUCT, FIELD), DESC_FLAG_OFFSET, ne_ ## FIELD ## _elements, 0, \
    323       offsetof(STRUCT, FIELD ## _offset) }
    324 #define E_SINGLE_MASTER(ID, TYPE, STRUCT, FIELD) \
    325   { #ID, ID, TYPE, offsetof(STRUCT, FIELD), DESC_FLAG_NONE, ne_ ## FIELD ## _elements, 0, 0 }
    326 #define E_SUSPEND(ID, TYPE) \
    327   { #ID, ID, TYPE, 0, DESC_FLAG_SUSPEND, NULL, 0, 0 }
    328 #define E_LAST \
    329   { NULL, 0, 0, 0, DESC_FLAG_NONE, NULL, 0, 0 }
    330 
    331 /* EBML Element Lists */
    332 static struct ebml_element_desc ne_ebml_elements[] = {
    333   E_FIELD(ID_EBML_VERSION, TYPE_UINT, struct ebml, ebml_version),
    334   E_FIELD(ID_EBML_READ_VERSION, TYPE_UINT, struct ebml, ebml_read_version),
    335   E_FIELD(ID_EBML_MAX_ID_LENGTH, TYPE_UINT, struct ebml, ebml_max_id_length),
    336   E_FIELD(ID_EBML_MAX_SIZE_LENGTH, TYPE_UINT, struct ebml, ebml_max_size_length),
    337   E_FIELD(ID_DOCTYPE, TYPE_STRING, struct ebml, doctype),
    338   E_FIELD(ID_DOCTYPE_VERSION, TYPE_UINT, struct ebml, doctype_version),
    339   E_FIELD(ID_DOCTYPE_READ_VERSION, TYPE_UINT, struct ebml, doctype_read_version),
    340   E_LAST
    341 };
    342 
    343 /* WebMedia Element Lists */
    344 static struct ebml_element_desc ne_seek_elements[] = {
    345   E_FIELD(ID_SEEK_ID, TYPE_BINARY, struct seek, id),
    346   E_FIELD(ID_SEEK_POSITION, TYPE_UINT, struct seek, position),
    347   E_LAST
    348 };
    349 
    350 static struct ebml_element_desc ne_seek_head_elements[] = {
    351   E_MASTER(ID_SEEK, TYPE_MASTER, struct seek_head, seek),
    352   E_LAST
    353 };
    354 
    355 static struct ebml_element_desc ne_info_elements[] = {
    356   E_FIELD(ID_TIMECODE_SCALE, TYPE_UINT, struct info, timecode_scale),
    357   E_FIELD(ID_DURATION, TYPE_FLOAT, struct info, duration),
    358   E_LAST
    359 };
    360 
    361 static struct ebml_element_desc ne_block_group_elements[] = {
    362   E_SUSPEND(ID_BLOCK, TYPE_BINARY),
    363   E_FIELD(ID_BLOCK_DURATION, TYPE_UINT, struct block_group, duration),
    364   E_FIELD(ID_REFERENCE_BLOCK, TYPE_INT, struct block_group, reference_block),
    365   E_LAST
    366 };
    367 
    368 static struct ebml_element_desc ne_cluster_elements[] = {
    369   E_FIELD(ID_TIMECODE, TYPE_UINT, struct cluster, timecode),
    370   E_MASTER(ID_BLOCK_GROUP, TYPE_MASTER, struct cluster, block_group),
    371   E_SUSPEND(ID_SIMPLE_BLOCK, TYPE_BINARY),
    372   E_LAST
    373 };
    374 
    375 static struct ebml_element_desc ne_video_elements[] = {
    376   E_FIELD(ID_PIXEL_WIDTH, TYPE_UINT, struct video, pixel_width),
    377   E_FIELD(ID_PIXEL_HEIGHT, TYPE_UINT, struct video, pixel_height),
    378   E_FIELD(ID_PIXEL_CROP_BOTTOM, TYPE_UINT, struct video, pixel_crop_bottom),
    379   E_FIELD(ID_PIXEL_CROP_TOP, TYPE_UINT, struct video, pixel_crop_top),
    380   E_FIELD(ID_PIXEL_CROP_LEFT, TYPE_UINT, struct video, pixel_crop_left),
    381   E_FIELD(ID_PIXEL_CROP_RIGHT, TYPE_UINT, struct video, pixel_crop_right),
    382   E_FIELD(ID_DISPLAY_WIDTH, TYPE_UINT, struct video, display_width),
    383   E_FIELD(ID_DISPLAY_HEIGHT, TYPE_UINT, struct video, display_height),
    384   E_LAST
    385 };
    386 
    387 static struct ebml_element_desc ne_audio_elements[] = {
    388   E_FIELD(ID_SAMPLING_FREQUENCY, TYPE_FLOAT, struct audio, sampling_frequency),
    389   E_FIELD(ID_CHANNELS, TYPE_UINT, struct audio, channels),
    390   E_FIELD(ID_BIT_DEPTH, TYPE_UINT, struct audio, bit_depth),
    391   E_LAST
    392 };
    393 
    394 static struct ebml_element_desc ne_track_entry_elements[] = {
    395   E_FIELD(ID_TRACK_NUMBER, TYPE_UINT, struct track_entry, number),
    396   E_FIELD(ID_TRACK_UID, TYPE_UINT, struct track_entry, uid),
    397   E_FIELD(ID_TRACK_TYPE, TYPE_UINT, struct track_entry, type),
    398   E_FIELD(ID_FLAG_ENABLED, TYPE_UINT, struct track_entry, flag_enabled),
    399   E_FIELD(ID_FLAG_DEFAULT, TYPE_UINT, struct track_entry, flag_default),
    400   E_FIELD(ID_FLAG_LACING, TYPE_UINT, struct track_entry, flag_lacing),
    401   E_FIELD(ID_TRACK_TIMECODE_SCALE, TYPE_FLOAT, struct track_entry, track_timecode_scale),
    402   E_FIELD(ID_LANGUAGE, TYPE_STRING, struct track_entry, language),
    403   E_FIELD(ID_CODEC_ID, TYPE_STRING, struct track_entry, codec_id),
    404   E_FIELD(ID_CODEC_PRIVATE, TYPE_BINARY, struct track_entry, codec_private),
    405   E_SINGLE_MASTER(ID_VIDEO, TYPE_MASTER, struct track_entry, video),
    406   E_SINGLE_MASTER(ID_AUDIO, TYPE_MASTER, struct track_entry, audio),
    407   E_LAST
    408 };
    409 
    410 static struct ebml_element_desc ne_tracks_elements[] = {
    411   E_MASTER(ID_TRACK_ENTRY, TYPE_MASTER, struct tracks, track_entry),
    412   E_LAST
    413 };
    414 
    415 static struct ebml_element_desc ne_cue_track_positions_elements[] = {
    416   E_FIELD(ID_CUE_TRACK, TYPE_UINT, struct cue_track_positions, track),
    417   E_FIELD(ID_CUE_CLUSTER_POSITION, TYPE_UINT, struct cue_track_positions, cluster_position),
    418   E_FIELD(ID_CUE_BLOCK_NUMBER, TYPE_UINT, struct cue_track_positions, block_number),
    419   E_LAST
    420 };
    421 
    422 static struct ebml_element_desc ne_cue_point_elements[] = {
    423   E_FIELD(ID_CUE_TIME, TYPE_UINT, struct cue_point, time),
    424   E_MASTER(ID_CUE_TRACK_POSITIONS, TYPE_MASTER, struct cue_point, cue_track_positions),
    425   E_LAST
    426 };
    427 
    428 static struct ebml_element_desc ne_cues_elements[] = {
    429   E_MASTER(ID_CUE_POINT, TYPE_MASTER, struct cues, cue_point),
    430   E_LAST
    431 };
    432 
    433 static struct ebml_element_desc ne_segment_elements[] = {
    434   E_MASTER(ID_SEEK_HEAD, TYPE_MASTER, struct segment, seek_head),
    435   E_SINGLE_MASTER(ID_INFO, TYPE_MASTER, struct segment, info),
    436   E_MASTER(ID_CLUSTER, TYPE_MASTER, struct segment, cluster),
    437   E_SINGLE_MASTER(ID_TRACKS, TYPE_MASTER, struct segment, tracks),
    438   E_SINGLE_MASTER(ID_CUES, TYPE_MASTER, struct segment, cues),
    439   E_LAST
    440 };
    441 
    442 static struct ebml_element_desc ne_top_level_elements[] = {
    443   E_SINGLE_MASTER(ID_EBML, TYPE_MASTER, nestegg, ebml),
    444   E_SINGLE_MASTER_O(ID_SEGMENT, TYPE_MASTER, nestegg, segment),
    445   E_LAST
    446 };
    447 
    448 #undef E_FIELD
    449 #undef E_MASTER
    450 #undef E_SINGLE_MASTER_O
    451 #undef E_SINGLE_MASTER
    452 #undef E_SUSPEND
    453 #undef E_LAST
    454 
    455 static struct pool_ctx *
    456 ne_pool_init(void)
    457 {
    458   struct pool_ctx * pool;
    459 
    460   pool = h_malloc(sizeof(*pool));
    461   if (!pool)
    462     abort();
    463   return pool;
    464 }
    465 
    466 static void
    467 ne_pool_destroy(struct pool_ctx * pool)
    468 {
    469   h_free(pool);
    470 }
    471 
    472 static void *
    473 ne_pool_alloc(size_t size, struct pool_ctx * pool)
    474 {
    475   void * p;
    476 
    477   p = h_malloc(size);
    478   if (!p)
    479     abort();
    480   hattach(p, pool);
    481   memset(p, 0, size);
    482   return p;
    483 }
    484 
    485 static void *
    486 ne_alloc(size_t size)
    487 {
    488   void * p;
    489 
    490   p = calloc(1, size);
    491   if (!p)
    492     abort();
    493   return p;
    494 }
    495 
    496 static int
    497 ne_io_read(nestegg_io * io, void * buffer, size_t length)
    498 {
    499   return io->read(buffer, length, io->userdata);
    500 }
    501 
    502 static int
    503 ne_io_seek(nestegg_io * io, int64_t offset, int whence)
    504 {
    505   return io->seek(offset, whence, io->userdata);
    506 }
    507 
    508 static int
    509 ne_io_read_skip(nestegg_io * io, size_t length)
    510 {
    511   size_t get;
    512   unsigned char buf[8192];
    513   int r = 1;
    514 
    515   while (length > 0) {
    516     get = length < sizeof(buf) ? length : sizeof(buf);
    517     r = ne_io_read(io, buf, get);
    518     if (r != 1)
    519       break;
    520     length -= get;
    521   }
    522 
    523   return r;
    524 }
    525 
    526 static int64_t
    527 ne_io_tell(nestegg_io * io)
    528 {
    529   return io->tell(io->userdata);
    530 }
    531 
    532 static int
    533 ne_bare_read_vint(nestegg_io * io, uint64_t * value, uint64_t * length, enum vint_mask maskflag)
    534 {
    535   int r;
    536   unsigned char b;
    537   size_t maxlen = 8;
    538   unsigned int count = 1, mask = 1 << 7;
    539 
    540   r = ne_io_read(io, &b, 1);
    541   if (r != 1)
    542     return r;
    543 
    544   while (count < maxlen) {
    545     if ((b & mask) != 0)
    546       break;
    547     mask >>= 1;
    548     count += 1;
    549   }
    550 
    551   if (length)
    552     *length = count;
    553   *value = b;
    554 
    555   if (maskflag == MASK_FIRST_BIT)
    556     *value = b & ~mask;
    557 
    558   while (--count) {
    559     r = ne_io_read(io, &b, 1);
    560     if (r != 1)
    561       return r;
    562     *value <<= 8;
    563     *value |= b;
    564   }
    565 
    566   return 1;
    567 }
    568 
    569 static int
    570 ne_read_id(nestegg_io * io, uint64_t * value, uint64_t * length)
    571 {
    572   return ne_bare_read_vint(io, value, length, MASK_NONE);
    573 }
    574 
    575 static int
    576 ne_read_vint(nestegg_io * io, uint64_t * value, uint64_t * length)
    577 {
    578   return ne_bare_read_vint(io, value, length, MASK_FIRST_BIT);
    579 }
    580 
    581 static int
    582 ne_read_svint(nestegg_io * io, int64_t * value, uint64_t * length)
    583 {
    584   int r;
    585   uint64_t uvalue;
    586   uint64_t ulength;
    587   int64_t svint_subtr[] = {
    588     0x3f, 0x1fff,
    589     0xfffff, 0x7ffffff,
    590     0x3ffffffffLL, 0x1ffffffffffLL,
    591     0xffffffffffffLL, 0x7fffffffffffffLL
    592   };
    593 
    594   r = ne_bare_read_vint(io, &uvalue, &ulength, MASK_FIRST_BIT);
    595   if (r != 1)
    596     return r;
    597   *value = uvalue - svint_subtr[ulength - 1];
    598   if (length)
    599     *length = ulength;
    600   return r;
    601 }
    602 
    603 static int
    604 ne_read_uint(nestegg_io * io, uint64_t * val, uint64_t length)
    605 {
    606   unsigned char b;
    607   int r;
    608 
    609   if (length == 0 || length > 8)
    610     return -1;
    611   r = ne_io_read(io, &b, 1);
    612   if (r != 1)
    613     return r;
    614   *val = b;
    615   while (--length) {
    616     r = ne_io_read(io, &b, 1);
    617     if (r != 1)
    618       return r;
    619     *val <<= 8;
    620     *val |= b;
    621   }
    622   return 1;
    623 }
    624 
    625 static int
    626 ne_read_int(nestegg_io * io, int64_t * val, uint64_t length)
    627 {
    628   int r;
    629   uint64_t uval, base;
    630 
    631   r = ne_read_uint(io, &uval, length);
    632   if (r != 1)
    633     return r;
    634 
    635   if (length < sizeof(int64_t)) {
    636     base = 1;
    637     base <<= length * 8 - 1;
    638     if (uval >= base) {
    639         base = 1;
    640         base <<= length * 8;
    641     } else {
    642       base = 0;
    643     }
    644     *val = uval - base;
    645   } else {
    646     *val = (int64_t) uval;
    647   }
    648 
    649   return 1;
    650 }
    651 
    652 static int
    653 ne_read_float(nestegg_io * io, double * val, uint64_t length)
    654 {
    655   union {
    656     uint64_t u;
    657     float f;
    658     double d;
    659   } value;
    660   int r;
    661 
    662   /* length == 10 not implemented */
    663   if (length != 4 && length != 8)
    664     return -1;
    665   r = ne_read_uint(io, &value.u, length);
    666   if (r != 1)
    667     return r;
    668   if (length == 4)
    669     *val = value.f;
    670   else
    671     *val = value.d;
    672   return 1;
    673 }
    674 
    675 static int
    676 ne_read_string(nestegg * ctx, char ** val, uint64_t length)
    677 {
    678   char * str;
    679   int r;
    680 
    681   if (length == 0 || length > LIMIT_STRING)
    682     return -1;
    683   str = ne_pool_alloc(length + 1, ctx->alloc_pool);
    684   r = ne_io_read(ctx->io, (unsigned char *) str, length);
    685   if (r != 1)
    686     return r;
    687   str[length] = '\0';
    688   *val = str;
    689   return 1;
    690 }
    691 
    692 static int
    693 ne_read_binary(nestegg * ctx, struct ebml_binary * val, uint64_t length)
    694 {
    695   if (length == 0 || length > LIMIT_BINARY)
    696     return -1;
    697   val->data = ne_pool_alloc(length, ctx->alloc_pool);
    698   val->length = length;
    699   return ne_io_read(ctx->io, val->data, length);
    700 }
    701 
    702 static int
    703 ne_get_uint(struct ebml_type type, uint64_t * value)
    704 {
    705   if (!type.read)
    706     return -1;
    707 
    708   assert(type.type == TYPE_UINT);
    709 
    710   *value = type.v.u;
    711 
    712   return 0;
    713 }
    714 
    715 static int
    716 ne_get_float(struct ebml_type type, double * value)
    717 {
    718   if (!type.read)
    719     return -1;
    720 
    721   assert(type.type == TYPE_FLOAT);
    722 
    723   *value = type.v.f;
    724 
    725   return 0;
    726 }
    727 
    728 static int
    729 ne_get_string(struct ebml_type type, char ** value)
    730 {
    731   if (!type.read)
    732     return -1;
    733 
    734   assert(type.type == TYPE_STRING);
    735 
    736   *value = type.v.s;
    737 
    738   return 0;
    739 }
    740 
    741 static int
    742 ne_get_binary(struct ebml_type type, struct ebml_binary * value)
    743 {
    744   if (!type.read)
    745     return -1;
    746 
    747   assert(type.type == TYPE_BINARY);
    748 
    749   *value = type.v.b;
    750 
    751   return 0;
    752 }
    753 
    754 static int
    755 ne_is_ancestor_element(uint64_t id, struct list_node * ancestor)
    756 {
    757   struct ebml_element_desc * element;
    758 
    759   for (; ancestor; ancestor = ancestor->previous)
    760     for (element = ancestor->node; element->id; ++element)
    761       if (element->id == id)
    762         return 1;
    763 
    764   return 0;
    765 }
    766 
    767 static struct ebml_element_desc *
    768 ne_find_element(uint64_t id, struct ebml_element_desc * elements)
    769 {
    770   struct ebml_element_desc * element;
    771 
    772   for (element = elements; element->id; ++element)
    773     if (element->id == id)
    774       return element;
    775 
    776   return NULL;
    777 }
    778 
    779 static void
    780 ne_ctx_push(nestegg * ctx, struct ebml_element_desc * ancestor, void * data)
    781 {
    782   struct list_node * item;
    783 
    784   item = ne_alloc(sizeof(*item));
    785   item->previous = ctx->ancestor;
    786   item->node = ancestor;
    787   item->data = data;
    788   ctx->ancestor = item;
    789 }
    790 
    791 static void
    792 ne_ctx_pop(nestegg * ctx)
    793 {
    794   struct list_node * item;
    795 
    796   item = ctx->ancestor;
    797   ctx->ancestor = item->previous;
    798   free(item);
    799 }
    800 
    801 static int
    802 ne_ctx_save(nestegg * ctx, struct saved_state * s)
    803 {
    804   s->stream_offset = ne_io_tell(ctx->io);
    805   if (s->stream_offset < 0)
    806     return -1;
    807   s->ancestor = ctx->ancestor;
    808   s->last_id = ctx->last_id;
    809   s->last_size = ctx->last_size;
    810   return 0;
    811 }
    812 
    813 static int
    814 ne_ctx_restore(nestegg * ctx, struct saved_state * s)
    815 {
    816   int r;
    817 
    818   r = ne_io_seek(ctx->io, s->stream_offset, NESTEGG_SEEK_SET);
    819   if (r != 0)
    820     return -1;
    821   ctx->ancestor = s->ancestor;
    822   ctx->last_id = s->last_id;
    823   ctx->last_size = s->last_size;
    824   return 0;
    825 }
    826 
    827 static int
    828 ne_peek_element(nestegg * ctx, uint64_t * id, uint64_t * size)
    829 {
    830   int r;
    831 
    832   if (ctx->last_id && ctx->last_size) {
    833     if (id)
    834       *id = ctx->last_id;
    835     if (size)
    836       *size = ctx->last_size;
    837     return 1;
    838   }
    839 
    840   r = ne_read_id(ctx->io, &ctx->last_id, NULL);
    841   if (r != 1)
    842     return r;
    843 
    844   r = ne_read_vint(ctx->io, &ctx->last_size, NULL);
    845   if (r != 1)
    846     return r;
    847 
    848   if (id)
    849     *id = ctx->last_id;
    850   if (size)
    851     *size = ctx->last_size;
    852 
    853   return 1;
    854 }
    855 
    856 static int
    857 ne_read_element(nestegg * ctx, uint64_t * id, uint64_t * size)
    858 {
    859   int r;
    860 
    861   r = ne_peek_element(ctx, id, size);
    862   if (r != 1)
    863     return r;
    864 
    865   ctx->last_id = 0;
    866   ctx->last_size = 0;
    867 
    868   return 1;
    869 }
    870 
    871 static void
    872 ne_read_master(nestegg * ctx, struct ebml_element_desc * desc)
    873 {
    874   struct ebml_list * list;
    875   struct ebml_list_node * node, * oldtail;
    876 
    877   assert(desc->type == TYPE_MASTER && desc->flags & DESC_FLAG_MULTI);
    878 
    879   ctx->log(ctx, NESTEGG_LOG_DEBUG, "multi master element %llx (%s)",
    880            desc->id, desc->name);
    881 
    882   list = (struct ebml_list *) (ctx->ancestor->data + desc->offset);
    883 
    884   node = ne_pool_alloc(sizeof(*node), ctx->alloc_pool);
    885   node->id = desc->id;
    886   node->data = ne_pool_alloc(desc->size, ctx->alloc_pool);
    887 
    888   oldtail = list->tail;
    889   if (oldtail)
    890     oldtail->next = node;
    891   list->tail = node;
    892   if (!list->head)
    893     list->head = node;
    894 
    895   ctx->log(ctx, NESTEGG_LOG_DEBUG, " -> using data %p", node->data);
    896 
    897   ne_ctx_push(ctx, desc->children, node->data);
    898 }
    899 
    900 static void
    901 ne_read_single_master(nestegg * ctx, struct ebml_element_desc * desc)
    902 {
    903   assert(desc->type == TYPE_MASTER && !(desc->flags & DESC_FLAG_MULTI));
    904 
    905   ctx->log(ctx, NESTEGG_LOG_DEBUG, "single master element %llx (%s)",
    906            desc->id, desc->name);
    907   ctx->log(ctx, NESTEGG_LOG_DEBUG, " -> using data %p (%u)",
    908            ctx->ancestor->data + desc->offset, desc->offset);
    909 
    910   ne_ctx_push(ctx, desc->children, ctx->ancestor->data + desc->offset);
    911 }
    912 
    913 static int
    914 ne_read_simple(nestegg * ctx, struct ebml_element_desc * desc, size_t length)
    915 {
    916   struct ebml_type * storage;
    917   int r;
    918 
    919   storage = (struct ebml_type *) (ctx->ancestor->data + desc->offset);
    920 
    921   if (storage->read) {
    922     ctx->log(ctx, NESTEGG_LOG_DEBUG, "element %llx (%s) already read, skipping",
    923              desc->id, desc->name);
    924     return 0;
    925   }
    926 
    927   storage->type = desc->type;
    928 
    929   ctx->log(ctx, NESTEGG_LOG_DEBUG, "element %llx (%s) -> %p (%u)",
    930            desc->id, desc->name, storage, desc->offset);
    931 
    932   r = -1;
    933 
    934   switch (desc->type) {
    935   case TYPE_UINT:
    936     r = ne_read_uint(ctx->io, &storage->v.u, length);
    937     break;
    938   case TYPE_FLOAT:
    939     r = ne_read_float(ctx->io, &storage->v.f, length);
    940     break;
    941   case TYPE_INT:
    942     r = ne_read_int(ctx->io, &storage->v.i, length);
    943     break;
    944   case TYPE_STRING:
    945     r = ne_read_string(ctx, &storage->v.s, length);
    946     break;
    947   case TYPE_BINARY:
    948     r = ne_read_binary(ctx, &storage->v.b, length);
    949     break;
    950   case TYPE_MASTER:
    951   case TYPE_UNKNOWN:
    952     assert(0);
    953     break;
    954   }
    955 
    956   if (r == 1)
    957     storage->read = 1;
    958 
    959   return r;
    960 }
    961 
    962 static int
    963 ne_parse(nestegg * ctx, struct ebml_element_desc * top_level)
    964 {
    965   int r;
    966   int64_t * data_offset;
    967   uint64_t id, size;
    968   struct ebml_element_desc * element;
    969 
    970   /* loop until we need to return:
    971      - hit suspend point
    972      - parse complete
    973      - error occurred */
    974 
    975   /* loop over elements at current level reading them if sublevel found,
    976      push ctx onto stack and continue if sublevel ended, pop ctx off stack
    977      and continue */
    978 
    979   if (!ctx->ancestor)
    980     return -1;
    981 
    982   for (;;) {
    983     r = ne_peek_element(ctx, &id, &size);
    984     if (r != 1)
    985       break;
    986 
    987     element = ne_find_element(id, ctx->ancestor->node);
    988     if (element) {
    989       if (element->flags & DESC_FLAG_SUSPEND) {
    990         assert(element->type == TYPE_BINARY);
    991         ctx->log(ctx, NESTEGG_LOG_DEBUG, "suspend parse at %llx", id);
    992         r = 1;
    993         break;
    994       }
    995 
    996       r = ne_read_element(ctx, &id, &size);
    997       if (r != 1)
    998         break;
    999 
   1000       if (element->flags & DESC_FLAG_OFFSET) {
   1001         data_offset = (int64_t *) (ctx->ancestor->data + element->data_offset);
   1002         *data_offset = ne_io_tell(ctx->io);
   1003         if (*data_offset < 0) {
   1004           r = -1;
   1005           break;
   1006         }
   1007       }
   1008 
   1009       if (element->type == TYPE_MASTER) {
   1010         if (element->flags & DESC_FLAG_MULTI)
   1011           ne_read_master(ctx, element);
   1012         else
   1013           ne_read_single_master(ctx, element);
   1014         continue;
   1015       } else {
   1016         r = ne_read_simple(ctx, element, size);
   1017         if (r < 0)
   1018           break;
   1019       }
   1020     } else if (ne_is_ancestor_element(id, ctx->ancestor->previous)) {
   1021       ctx->log(ctx, NESTEGG_LOG_DEBUG, "parent element %llx", id);
   1022       if (top_level && ctx->ancestor->node == top_level) {
   1023         ctx->log(ctx, NESTEGG_LOG_DEBUG, "*** parse about to back up past top_level");
   1024         r = 1;
   1025         break;
   1026       }
   1027       ne_ctx_pop(ctx);
   1028     } else {
   1029       r = ne_read_element(ctx, &id, &size);
   1030       if (r != 1)
   1031         break;
   1032 
   1033       if (id != ID_VOID && id != ID_CRC32)
   1034         ctx->log(ctx, NESTEGG_LOG_DEBUG, "unknown element %llx", id);
   1035       r = ne_io_read_skip(ctx->io, size);
   1036       if (r != 1)
   1037         break;
   1038     }
   1039   }
   1040 
   1041   if (r != 1)
   1042     while (ctx->ancestor)
   1043       ne_ctx_pop(ctx);
   1044 
   1045   return r;
   1046 }
   1047 
   1048 static uint64_t
   1049 ne_xiph_lace_value(unsigned char ** np)
   1050 {
   1051   uint64_t lace;
   1052   uint64_t value;
   1053   unsigned char * p = *np;
   1054 
   1055   lace = *p++;
   1056   value = lace;
   1057   while (lace == 255) {
   1058     lace = *p++;
   1059     value += lace;
   1060   }
   1061 
   1062   *np = p;
   1063 
   1064   return value;
   1065 }
   1066 
   1067 static int
   1068 ne_read_xiph_lace_value(nestegg_io * io, uint64_t * value, size_t * consumed)
   1069 {
   1070   int r;
   1071   uint64_t lace;
   1072 
   1073   r = ne_read_uint(io, &lace, 1);
   1074   if (r != 1)
   1075     return r;
   1076   *consumed += 1;
   1077 
   1078   *value = lace;
   1079   while (lace == 255) {
   1080     r = ne_read_uint(io, &lace, 1);
   1081     if (r != 1)
   1082       return r;
   1083     *consumed += 1;
   1084     *value += lace;
   1085   }
   1086 
   1087   return 1;
   1088 }
   1089 
   1090 static int
   1091 ne_read_xiph_lacing(nestegg_io * io, size_t block, size_t * read, uint64_t n, uint64_t * sizes)
   1092 {
   1093   int r;
   1094   size_t i = 0;
   1095   uint64_t sum = 0;
   1096 
   1097   while (--n) {
   1098     r = ne_read_xiph_lace_value(io, &sizes[i], read);
   1099     if (r != 1)
   1100       return r;
   1101     sum += sizes[i];
   1102     i += 1;
   1103   }
   1104 
   1105   if (*read + sum > block)
   1106     return -1;
   1107 
   1108   /* last frame is the remainder of the block */
   1109   sizes[i] = block - *read - sum;
   1110   return 1;
   1111 }
   1112 
   1113 static int
   1114 ne_read_ebml_lacing(nestegg_io * io, size_t block, size_t * read, uint64_t n, uint64_t * sizes)
   1115 {
   1116   int r;
   1117   uint64_t lace, sum, length;
   1118   int64_t slace;
   1119   size_t i = 0;
   1120 
   1121   r = ne_read_vint(io, &lace, &length);
   1122   if (r != 1)
   1123     return r;
   1124   *read += length;
   1125 
   1126   sizes[i] = lace;
   1127   sum = sizes[i];
   1128 
   1129   i += 1;
   1130   n -= 1;
   1131 
   1132   while (--n) {
   1133     r = ne_read_svint(io, &slace, &length);
   1134     if (r != 1)
   1135       return r;
   1136     *read += length;
   1137     sizes[i] = sizes[i - 1] + slace;
   1138     sum += sizes[i];
   1139     i += 1;
   1140   }
   1141 
   1142   if (*read + sum > block)
   1143     return -1;
   1144 
   1145   /* last frame is the remainder of the block */
   1146   sizes[i] = block - *read - sum;
   1147   return 1;
   1148 }
   1149 
   1150 static uint64_t
   1151 ne_get_timecode_scale(nestegg * ctx)
   1152 {
   1153   uint64_t scale;
   1154 
   1155   if (ne_get_uint(ctx->segment.info.timecode_scale, &scale) != 0)
   1156     scale = 1000000;
   1157 
   1158   return scale;
   1159 }
   1160 
   1161 static struct track_entry *
   1162 ne_find_track_entry(nestegg * ctx, unsigned int track)
   1163 {
   1164   struct ebml_list_node * node;
   1165   unsigned int tracks = 0;
   1166 
   1167   node = ctx->segment.tracks.track_entry.head;
   1168   while (node) {
   1169     assert(node->id == ID_TRACK_ENTRY);
   1170     if (track == tracks)
   1171       return node->data;
   1172     tracks += 1;
   1173     node = node->next;
   1174   }
   1175 
   1176   return NULL;
   1177 }
   1178 
   1179 static int
   1180 ne_read_block(nestegg * ctx, uint64_t block_id, uint64_t block_size, nestegg_packet ** data)
   1181 {
   1182   int r;
   1183   int64_t timecode, abs_timecode;
   1184   nestegg_packet * pkt;
   1185   struct cluster * cluster;
   1186   struct frame * f, * last;
   1187   struct track_entry * entry;
   1188   double track_scale;
   1189   uint64_t track, length, frame_sizes[256], cluster_tc, flags, frames, tc_scale, total;
   1190   unsigned int i, lacing;
   1191   size_t consumed = 0;
   1192 
   1193   *data = NULL;
   1194 
   1195   if (block_size > LIMIT_BLOCK)
   1196     return -1;
   1197 
   1198   r = ne_read_vint(ctx->io, &track, &length);
   1199   if (r != 1)
   1200     return r;
   1201 
   1202   if (track == 0 || track > ctx->track_count)
   1203     return -1;
   1204 
   1205   consumed += length;
   1206 
   1207   r = ne_read_int(ctx->io, &timecode, 2);
   1208   if (r != 1)
   1209     return r;
   1210 
   1211   consumed += 2;
   1212 
   1213   r = ne_read_uint(ctx->io, &flags, 1);
   1214   if (r != 1)
   1215     return r;
   1216 
   1217   consumed += 1;
   1218 
   1219   frames = 0;
   1220 
   1221   /* flags are different between block and simpleblock, but lacing is
   1222      encoded the same way */
   1223   lacing = (flags & BLOCK_FLAGS_LACING) >> 1;
   1224 
   1225   switch (lacing) {
   1226   case LACING_NONE:
   1227     frames = 1;
   1228     break;
   1229   case LACING_XIPH:
   1230   case LACING_FIXED:
   1231   case LACING_EBML:
   1232     r = ne_read_uint(ctx->io, &frames, 1);
   1233     if (r != 1)
   1234       return r;
   1235     consumed += 1;
   1236     frames += 1;
   1237   }
   1238 
   1239   if (frames > 256)
   1240     return -1;
   1241 
   1242   switch (lacing) {
   1243   case LACING_NONE:
   1244     frame_sizes[0] = block_size - consumed;
   1245     break;
   1246   case LACING_XIPH:
   1247     if (frames == 1)
   1248       return -1;
   1249     r = ne_read_xiph_lacing(ctx->io, block_size, &consumed, frames, frame_sizes);
   1250     if (r != 1)
   1251       return r;
   1252     break;
   1253   case LACING_FIXED:
   1254     if ((block_size - consumed) % frames)
   1255       return -1;
   1256     for (i = 0; i < frames; ++i)
   1257       frame_sizes[i] = (block_size - consumed) / frames;
   1258     break;
   1259   case LACING_EBML:
   1260     if (frames == 1)
   1261       return -1;
   1262     r = ne_read_ebml_lacing(ctx->io, block_size, &consumed, frames, frame_sizes);
   1263     if (r != 1)
   1264       return r;
   1265     break;
   1266   }
   1267 
   1268   /* sanity check unlaced frame sizes against total block size. */
   1269   total = consumed;
   1270   for (i = 0; i < frames; ++i)
   1271     total += frame_sizes[i];
   1272   if (total > block_size)
   1273     return -1;
   1274 
   1275   entry = ne_find_track_entry(ctx, track - 1);
   1276   if (!entry)
   1277     return -1;
   1278 
   1279   track_scale = 1.0;
   1280 
   1281   tc_scale = ne_get_timecode_scale(ctx);
   1282 
   1283   assert(ctx->segment.cluster.tail->id == ID_CLUSTER);
   1284   cluster = ctx->segment.cluster.tail->data;
   1285   if (ne_get_uint(cluster->timecode, &cluster_tc) != 0)
   1286     return -1;
   1287 
   1288   abs_timecode = timecode + cluster_tc;
   1289   if (abs_timecode < 0)
   1290     return -1;
   1291 
   1292   pkt = ne_alloc(sizeof(*pkt));
   1293   pkt->track = track - 1;
   1294   pkt->timecode = abs_timecode * tc_scale * track_scale;
   1295 
   1296   ctx->log(ctx, NESTEGG_LOG_DEBUG, "%sblock t %lld pts %f f %llx frames: %llu",
   1297            block_id == ID_BLOCK ? "" : "simple", pkt->track, pkt->timecode / 1e9, flags, frames);
   1298 
   1299   last = NULL;
   1300   for (i = 0; i < frames; ++i) {
   1301     if (frame_sizes[i] > LIMIT_FRAME) {
   1302       nestegg_free_packet(pkt);
   1303       return -1;
   1304     }
   1305     f = ne_alloc(sizeof(*f));
   1306     f->data = ne_alloc(frame_sizes[i]);
   1307     f->length = frame_sizes[i];
   1308     r = ne_io_read(ctx->io, f->data, frame_sizes[i]);
   1309     if (r != 1) {
   1310       free(f->data);
   1311       free(f);
   1312       nestegg_free_packet(pkt);
   1313       return -1;
   1314     }
   1315 
   1316     if (!last)
   1317       pkt->frame = f;
   1318     else
   1319       last->next = f;
   1320     last = f;
   1321   }
   1322 
   1323   *data = pkt;
   1324 
   1325   return 1;
   1326 }
   1327 
   1328 static uint64_t
   1329 ne_buf_read_id(unsigned char const * p, size_t length)
   1330 {
   1331   uint64_t id = 0;
   1332 
   1333   while (length--) {
   1334     id <<= 8;
   1335     id |= *p++;
   1336   }
   1337 
   1338   return id;
   1339 }
   1340 
   1341 static struct seek *
   1342 ne_find_seek_for_id(struct ebml_list_node * seek_head, uint64_t id)
   1343 {
   1344   struct ebml_list * head;
   1345   struct ebml_list_node * seek;
   1346   struct ebml_binary binary_id;
   1347   struct seek * s;
   1348 
   1349   while (seek_head) {
   1350     assert(seek_head->id == ID_SEEK_HEAD);
   1351     head = seek_head->data;
   1352     seek = head->head;
   1353 
   1354     while (seek) {
   1355       assert(seek->id == ID_SEEK);
   1356       s = seek->data;
   1357 
   1358       if (ne_get_binary(s->id, &binary_id) == 0 &&
   1359           ne_buf_read_id(binary_id.data, binary_id.length) == id)
   1360         return s;
   1361 
   1362       seek = seek->next;
   1363     }
   1364 
   1365     seek_head = seek_head->next;
   1366   }
   1367 
   1368   return NULL;
   1369 }
   1370 
   1371 static struct cue_point *
   1372 ne_find_cue_point_for_tstamp(struct ebml_list_node * cue_point, uint64_t scale, uint64_t tstamp)
   1373 {
   1374   uint64_t time;
   1375   struct cue_point * c, * prev = NULL;
   1376 
   1377   while (cue_point) {
   1378     assert(cue_point->id == ID_CUE_POINT);
   1379     c = cue_point->data;
   1380 
   1381     if (!prev)
   1382       prev = c;
   1383 
   1384     if (ne_get_uint(c->time, &time) == 0 && time * scale > tstamp)
   1385       break;
   1386 
   1387     prev = cue_point->data;
   1388     cue_point = cue_point->next;
   1389   }
   1390 
   1391   return prev;
   1392 }
   1393 
   1394 static int
   1395 ne_is_suspend_element(uint64_t id)
   1396 {
   1397   /* this could search the tree of elements for DESC_FLAG_SUSPEND */
   1398   if (id == ID_SIMPLE_BLOCK || id == ID_BLOCK)
   1399     return 1;
   1400   return 0;
   1401 }
   1402 
   1403 static void
   1404 ne_null_log_callback(nestegg * ctx, unsigned int severity, char const * fmt, ...)
   1405 {
   1406   if (ctx && severity && fmt)
   1407     return;
   1408 }
   1409 
   1410 int
   1411 nestegg_init(nestegg ** context, nestegg_io io, nestegg_log callback)
   1412 {
   1413   int r;
   1414   uint64_t id, version, docversion;
   1415   struct ebml_list_node * track;
   1416   char * doctype;
   1417   nestegg * ctx = NULL;
   1418 
   1419   if (!(io.read && io.seek && io.tell))
   1420     return -1;
   1421 
   1422   ctx = ne_alloc(sizeof(*ctx));
   1423 
   1424   ctx->io = ne_alloc(sizeof(*ctx->io));
   1425   *ctx->io = io;
   1426   ctx->log = callback;
   1427   ctx->alloc_pool = ne_pool_init();
   1428 
   1429   if (!ctx->log)
   1430     ctx->log = ne_null_log_callback;
   1431 
   1432   r = ne_peek_element(ctx, &id, NULL);
   1433   if (r != 1) {
   1434     nestegg_destroy(ctx);
   1435     return -1;
   1436   }
   1437 
   1438   if (id != ID_EBML) {
   1439     nestegg_destroy(ctx);
   1440     return -1;
   1441   }
   1442 
   1443   ctx->log(ctx, NESTEGG_LOG_DEBUG, "ctx %p", ctx);
   1444 
   1445   ne_ctx_push(ctx, ne_top_level_elements, ctx);
   1446 
   1447   r = ne_parse(ctx, NULL);
   1448 
   1449   if (r != 1) {
   1450     nestegg_destroy(ctx);
   1451     return -1;
   1452   }
   1453 
   1454   if (ne_get_uint(ctx->ebml.ebml_read_version, &version) != 0)
   1455     version = 1;
   1456   if (version != 1) {
   1457     nestegg_destroy(ctx);
   1458     return -1;
   1459   }
   1460 
   1461   if (ne_get_string(ctx->ebml.doctype, &doctype) != 0)
   1462     doctype = "matroska";
   1463   if (strcmp(doctype, "webm") != 0) {
   1464     nestegg_destroy(ctx);
   1465     return -1;
   1466   }
   1467 
   1468   if (ne_get_uint(ctx->ebml.doctype_read_version, &docversion) != 0)
   1469     docversion = 1;
   1470   if (docversion < 1 || docversion > 2) {
   1471     nestegg_destroy(ctx);
   1472     return -1;
   1473   }
   1474 
   1475   if (!ctx->segment.tracks.track_entry.head) {
   1476     nestegg_destroy(ctx);
   1477     return -1;
   1478   }
   1479 
   1480   track = ctx->segment.tracks.track_entry.head;
   1481   ctx->track_count = 0;
   1482 
   1483   while (track) {
   1484     ctx->track_count += 1;
   1485     track = track->next;
   1486   }
   1487 
   1488   *context = ctx;
   1489 
   1490   return 0;
   1491 }
   1492 
   1493 void
   1494 nestegg_destroy(nestegg * ctx)
   1495 {
   1496   while (ctx->ancestor)
   1497     ne_ctx_pop(ctx);
   1498   ne_pool_destroy(ctx->alloc_pool);
   1499   free(ctx->io);
   1500   free(ctx);
   1501 }
   1502 
   1503 int
   1504 nestegg_duration(nestegg * ctx, uint64_t * duration)
   1505 {
   1506   uint64_t tc_scale;
   1507   double unscaled_duration;
   1508 
   1509   if (ne_get_float(ctx->segment.info.duration, &unscaled_duration) != 0)
   1510     return -1;
   1511 
   1512   tc_scale = ne_get_timecode_scale(ctx);
   1513 
   1514   *duration = (uint64_t) (unscaled_duration * tc_scale);
   1515   return 0;
   1516 }
   1517 
   1518 int
   1519 nestegg_tstamp_scale(nestegg * ctx, uint64_t * scale)
   1520 {
   1521   *scale = ne_get_timecode_scale(ctx);
   1522   return 0;
   1523 }
   1524 
   1525 int
   1526 nestegg_track_count(nestegg * ctx, unsigned int * tracks)
   1527 {
   1528   *tracks = ctx->track_count;
   1529   return 0;
   1530 }
   1531 
   1532 int
   1533 nestegg_track_seek(nestegg * ctx, unsigned int track, uint64_t tstamp)
   1534 {
   1535   int r;
   1536   struct cue_point * cue_point;
   1537   struct cue_track_positions * pos;
   1538   struct saved_state state;
   1539   struct seek * found;
   1540   uint64_t seek_pos, tc_scale, t, id;
   1541   struct ebml_list_node * node = ctx->segment.cues.cue_point.head;
   1542 
   1543   /* If there are no cues loaded, check for cues element in the seek head
   1544      and load it. */
   1545   if (!node) {
   1546     found = ne_find_seek_for_id(ctx->segment.seek_head.head, ID_CUES);
   1547     if (!found)
   1548       return -1;
   1549 
   1550     if (ne_get_uint(found->position, &seek_pos) != 0)
   1551       return -1;
   1552 
   1553     /* Save old parser state. */
   1554     r = ne_ctx_save(ctx, &state);
   1555     if (r != 0)
   1556       return -1;
   1557 
   1558     /* Seek and set up parser state for segment-level element (Cues). */
   1559     r = ne_io_seek(ctx->io, ctx->segment_offset + seek_pos, NESTEGG_SEEK_SET);
   1560     if (r != 0)
   1561       return -1;
   1562     ctx->last_id = 0;
   1563     ctx->last_size = 0;
   1564 
   1565     r = ne_read_element(ctx, &id, NULL);
   1566     if (r != 1)
   1567       return -1;
   1568 
   1569     if (id != ID_CUES)
   1570       return -1;
   1571 
   1572     ctx->ancestor = NULL;
   1573     ne_ctx_push(ctx, ne_top_level_elements, ctx);
   1574     ne_ctx_push(ctx, ne_segment_elements, &ctx->segment);
   1575     ne_ctx_push(ctx, ne_cues_elements, &ctx->segment.cues);
   1576     /* parser will run until end of cues element. */
   1577     ctx->log(ctx, NESTEGG_LOG_DEBUG, "seek: parsing cue elements");
   1578     r = ne_parse(ctx, ne_cues_elements);
   1579     while (ctx->ancestor)
   1580       ne_ctx_pop(ctx);
   1581 
   1582     /* Reset parser state to original state and seek back to old position. */
   1583     if (ne_ctx_restore(ctx, &state) != 0)
   1584       return -1;
   1585 
   1586     if (r < 0)
   1587       return -1;
   1588   }
   1589 
   1590   tc_scale = ne_get_timecode_scale(ctx);
   1591 
   1592   cue_point = ne_find_cue_point_for_tstamp(ctx->segment.cues.cue_point.head, tc_scale, tstamp);
   1593   if (!cue_point)
   1594     return -1;
   1595 
   1596   node = cue_point->cue_track_positions.head;
   1597 
   1598   seek_pos = 0;
   1599 
   1600   while (node) {
   1601     assert(node->id == ID_CUE_TRACK_POSITIONS);
   1602     pos = node->data;
   1603     if (ne_get_uint(pos->track, &t) == 0 && t - 1 == track) {
   1604       if (ne_get_uint(pos->cluster_position, &seek_pos) != 0)
   1605         return -1;
   1606       break;
   1607     }
   1608     node = node->next;
   1609   }
   1610 
   1611   /* Seek and set up parser state for segment-level element (Cluster). */
   1612   r = ne_io_seek(ctx->io, ctx->segment_offset + seek_pos, NESTEGG_SEEK_SET);
   1613   if (r != 0)
   1614     return -1;
   1615   ctx->last_id = 0;
   1616   ctx->last_size = 0;
   1617 
   1618   while (ctx->ancestor)
   1619     ne_ctx_pop(ctx);
   1620 
   1621   ne_ctx_push(ctx, ne_top_level_elements, ctx);
   1622   ne_ctx_push(ctx, ne_segment_elements, &ctx->segment);
   1623   ctx->log(ctx, NESTEGG_LOG_DEBUG, "seek: parsing cluster elements");
   1624   r = ne_parse(ctx, NULL);
   1625   if (r != 1)
   1626     return -1;
   1627 
   1628   if (!ne_is_suspend_element(ctx->last_id))
   1629     return -1;
   1630 
   1631   return 0;
   1632 }
   1633 
   1634 int
   1635 nestegg_track_type(nestegg * ctx, unsigned int track)
   1636 {
   1637   struct track_entry * entry;
   1638   uint64_t type;
   1639 
   1640   entry = ne_find_track_entry(ctx, track);
   1641   if (!entry)
   1642     return -1;
   1643 
   1644   if (ne_get_uint(entry->type, &type) != 0)
   1645     return -1;
   1646 
   1647   if (type & TRACK_TYPE_VIDEO)
   1648     return NESTEGG_TRACK_VIDEO;
   1649 
   1650   if (type & TRACK_TYPE_AUDIO)
   1651     return NESTEGG_TRACK_AUDIO;
   1652 
   1653   return -1;
   1654 }
   1655 
   1656 int
   1657 nestegg_track_codec_id(nestegg * ctx, unsigned int track)
   1658 {
   1659   char * codec_id;
   1660   struct track_entry * entry;
   1661 
   1662   entry = ne_find_track_entry(ctx, track);
   1663   if (!entry)
   1664     return -1;
   1665 
   1666   if (ne_get_string(entry->codec_id, &codec_id) != 0)
   1667     return -1;
   1668 
   1669   if (strcmp(codec_id, TRACK_ID_VP8) == 0)
   1670     return NESTEGG_CODEC_VP8;
   1671 
   1672   if (strcmp(codec_id, TRACK_ID_VORBIS) == 0)
   1673     return NESTEGG_CODEC_VORBIS;
   1674 
   1675   return -1;
   1676 }
   1677 
   1678 int
   1679 nestegg_track_codec_data_count(nestegg * ctx, unsigned int track,
   1680                                unsigned int * count)
   1681 {
   1682   struct track_entry * entry;
   1683   struct ebml_binary codec_private;
   1684   unsigned char * p;
   1685 
   1686   *count = 0;
   1687 
   1688   entry = ne_find_track_entry(ctx, track);
   1689   if (!entry)
   1690     return -1;
   1691 
   1692   if (nestegg_track_codec_id(ctx, track) != NESTEGG_CODEC_VORBIS)
   1693     return -1;
   1694 
   1695   if (ne_get_binary(entry->codec_private, &codec_private) != 0)
   1696     return -1;
   1697 
   1698   if (codec_private.length < 1)
   1699     return -1;
   1700 
   1701   p = codec_private.data;
   1702   *count = *p + 1;
   1703 
   1704   if (*count > 3)
   1705     return -1;
   1706 
   1707   return 0;
   1708 }
   1709 
   1710 int
   1711 nestegg_track_codec_data(nestegg * ctx, unsigned int track, unsigned int item,
   1712                          unsigned char ** data, size_t * length)
   1713 {
   1714   struct track_entry * entry;
   1715   struct ebml_binary codec_private;
   1716   uint64_t sizes[3], total;
   1717   unsigned char * p;
   1718   unsigned int count, i;
   1719 
   1720   *data = NULL;
   1721   *length = 0;
   1722 
   1723   entry = ne_find_track_entry(ctx, track);
   1724   if (!entry)
   1725     return -1;
   1726 
   1727   if (nestegg_track_codec_id(ctx, track) != NESTEGG_CODEC_VORBIS)
   1728     return -1;
   1729 
   1730   if (ne_get_binary(entry->codec_private, &codec_private) != 0)
   1731     return -1;
   1732 
   1733   p = codec_private.data;
   1734   count = *p++ + 1;
   1735 
   1736   if (count > 3)
   1737     return -1;
   1738 
   1739   i = 0;
   1740   total = 0;
   1741   while (--count) {
   1742     sizes[i] = ne_xiph_lace_value(&p);
   1743     total += sizes[i];
   1744     i += 1;
   1745   }
   1746   sizes[i] = codec_private.length - total - (p - codec_private.data);
   1747 
   1748   for (i = 0; i < item; ++i) {
   1749     if (sizes[i] > LIMIT_FRAME)
   1750       return -1;
   1751     p += sizes[i];
   1752   }
   1753   *data = p;
   1754   *length = sizes[item];
   1755 
   1756   return 0;
   1757 }
   1758 
   1759 int
   1760 nestegg_track_video_params(nestegg * ctx, unsigned int track,
   1761                            nestegg_video_params * params)
   1762 {
   1763   struct track_entry * entry;
   1764   uint64_t value;
   1765 
   1766   memset(params, 0, sizeof(*params));
   1767 
   1768   entry = ne_find_track_entry(ctx, track);
   1769   if (!entry)
   1770     return -1;
   1771 
   1772   if (nestegg_track_type(ctx, track) != NESTEGG_TRACK_VIDEO)
   1773     return -1;
   1774 
   1775   if (ne_get_uint(entry->video.pixel_width, &value) != 0)
   1776     return -1;
   1777   params->width = value;
   1778 
   1779   if (ne_get_uint(entry->video.pixel_height, &value) != 0)
   1780     return -1;
   1781   params->height = value;
   1782 
   1783   value = 0;
   1784   ne_get_uint(entry->video.pixel_crop_bottom, &value);
   1785   params->crop_bottom = value;
   1786 
   1787   value = 0;
   1788   ne_get_uint(entry->video.pixel_crop_top, &value);
   1789   params->crop_top = value;
   1790 
   1791   value = 0;
   1792   ne_get_uint(entry->video.pixel_crop_left, &value);
   1793   params->crop_left = value;
   1794 
   1795   value = 0;
   1796   ne_get_uint(entry->video.pixel_crop_right, &value);
   1797   params->crop_right = value;
   1798 
   1799   value = params->width;
   1800   ne_get_uint(entry->video.display_width, &value);
   1801   params->display_width = value;
   1802 
   1803   value = params->height;
   1804   ne_get_uint(entry->video.display_height, &value);
   1805   params->display_height = value;
   1806 
   1807   return 0;
   1808 }
   1809 
   1810 int
   1811 nestegg_track_audio_params(nestegg * ctx, unsigned int track,
   1812                            nestegg_audio_params * params)
   1813 {
   1814   struct track_entry * entry;
   1815   uint64_t value;
   1816 
   1817   memset(params, 0, sizeof(*params));
   1818 
   1819   entry = ne_find_track_entry(ctx, track);
   1820   if (!entry)
   1821     return -1;
   1822 
   1823   if (nestegg_track_type(ctx, track) != NESTEGG_TRACK_AUDIO)
   1824     return -1;
   1825 
   1826   params->rate = 8000;
   1827   ne_get_float(entry->audio.sampling_frequency, &params->rate);
   1828 
   1829   value = 1;
   1830   ne_get_uint(entry->audio.channels, &value);
   1831   params->channels = value;
   1832 
   1833   value = 16;
   1834   ne_get_uint(entry->audio.bit_depth, &value);
   1835   params->depth = value;
   1836 
   1837   return 0;
   1838 }
   1839 
   1840 int
   1841 nestegg_read_packet(nestegg * ctx, nestegg_packet ** pkt)
   1842 {
   1843   int r;
   1844   uint64_t id, size;
   1845 
   1846   *pkt = NULL;
   1847 
   1848   for (;;) {
   1849     r = ne_peek_element(ctx, &id, &size);
   1850     if (r != 1)
   1851       return r;
   1852 
   1853     /* any suspend fields must be handled here */
   1854     if (ne_is_suspend_element(id)) {
   1855       r = ne_read_element(ctx, &id, &size);
   1856       if (r != 1)
   1857         return r;
   1858 
   1859       /* the only suspend fields are blocks and simple blocks, which we
   1860          handle directly. */
   1861       r = ne_read_block(ctx, id, size, pkt);
   1862       return r;
   1863     }
   1864 
   1865     r =  ne_parse(ctx, NULL);
   1866     if (r != 1)
   1867       return r;
   1868   }
   1869 
   1870   return 1;
   1871 }
   1872 
   1873 void
   1874 nestegg_free_packet(nestegg_packet * pkt)
   1875 {
   1876   struct frame * frame;
   1877 
   1878   while (pkt->frame) {
   1879     frame = pkt->frame;
   1880     pkt->frame = frame->next;
   1881     free(frame->data);
   1882     free(frame);
   1883   }
   1884 
   1885  free(pkt);
   1886 }
   1887 
   1888 int
   1889 nestegg_packet_track(nestegg_packet * pkt, unsigned int * track)
   1890 {
   1891   *track = pkt->track;
   1892   return 0;
   1893 }
   1894 
   1895 int
   1896 nestegg_packet_tstamp(nestegg_packet * pkt, uint64_t * tstamp)
   1897 {
   1898   *tstamp = pkt->timecode;
   1899   return 0;
   1900 }
   1901 
   1902 int
   1903 nestegg_packet_count(nestegg_packet * pkt, unsigned int * count)
   1904 {
   1905   struct frame * f = pkt->frame;
   1906 
   1907   *count = 0;
   1908 
   1909   while (f) {
   1910     *count += 1;
   1911     f = f->next;
   1912   }
   1913 
   1914   return 0;
   1915 }
   1916 
   1917 int
   1918 nestegg_packet_data(nestegg_packet * pkt, unsigned int item,
   1919                     unsigned char ** data, size_t * length)
   1920 {
   1921   struct frame * f = pkt->frame;
   1922   unsigned int count = 0;
   1923 
   1924   *data = NULL;
   1925   *length = 0;
   1926 
   1927   while (f) {
   1928     if (count == item) {
   1929       *data = f->data;
   1930       *length = f->length;
   1931       return 0;
   1932     }
   1933     count += 1;
   1934     f = f->next;
   1935   }
   1936 
   1937   return -1;
   1938 }
   1939