Author: ods15 Date: Sat Feb 25 16:52:47 2006 New Revision: 73 Log: add nutindex util Added: trunk/nututils/nutindex.c Modified: trunk/nututils/Makefile Modified: trunk/nututils/Makefile ============================================================================== --- trunk/nututils/Makefile (original) +++ trunk/nututils/Makefile Sat Feb 25 16:52:47 2006 @@ -2,7 +2,7 @@ CFLAGS += -I../libnut -lm -all: riffreader avireader oggreader nutmerge +all: riffreader avireader oggreader nutmerge nutindex riffreader: demux_avi.c ${CC} ${CFLAGS} -DRIFF_PROG $^ -o $@ @@ -12,6 +12,8 @@ ${CC} ${CFLAGS} -DOGG_PROG $^ -o $@ nutmerge: demux_ogg.c demux_nut.c demux_avi.c nutmerge.c ../libnut/libnut.so ${CC} ${CFLAGS} $^ -o $@ +nutindex: nutindex.c + ${CC} ${CFLAGS} $^ -o $@ clean: rm -f *\~ nutmerge avireader oggreader riffreader *.o Added: trunk/nututils/nutindex.c ============================================================================== --- trunk/nututils/nutindex.c (added) +++ trunk/nututils/nutindex.c Sat Feb 25 16:52:47 2006 @@ -1,0 +1,350 @@ +#include <stdio.h> +#include <stdlib.h> +#include <inttypes.h> +#include <assert.h> +#include <string.h> + +#define ID_STRING "nut/multimedia container" + +#define MAIN_STARTCODE (0x7A561F5F04ADULL + (((uint64_t)('N'<<8) + 'M')<<48)) +#define STREAM_STARTCODE (0x11405BF2F9DBULL + (((uint64_t)('N'<<8) + 'S')<<48)) +#define SYNCPOINT_STARTCODE (0xE4ADEECA4569ULL + (((uint64_t)('N'<<8) + 'K')<<48)) +#define INDEX_STARTCODE (0xDD672F23E64EULL + (((uint64_t)('N'<<8) + 'X')<<48)) +#define INFO_STARTCODE (0xAB68B596BA78ULL + (((uint64_t)('N'<<8) + 'I')<<48)) + +#define PREALLOC_SIZE 4096 + +#define MIN(a,b) ((a) < (b) ? (a) : (b)) +#define MAX(a,b) ((a) > (b) ? (a) : (b)) +#define ABS(a) ((a) > 0 ? (a) : -(a)) + +#define bctello(bc) ((bc)->file_pos + ((bc)->buf_ptr - (bc)->buf)) + +static inline uint32_t crc32(uint8_t * buf, int len){ + uint32_t crc = 0; + int i; + while (len--) { + crc ^= *buf++ << 24; + for(i = 0; i < 8; i++) crc = (crc<<1) ^ (0x1EDC6F41 & (crc>>31)); + } + return crc; +} + +// ============ OUTPUT BUFFER ============== + +typedef struct { + int is_mem; + uint8_t * buf; + uint8_t * buf_ptr; + int write_len; // memory allocated + off_t file_pos; + FILE * out; +} output_buffer_t; + +static void flush_out_buf(output_buffer_t * bc) { + assert(!bc->is_mem); + bc->file_pos += fwrite(bc->buf, 1, bc->buf_ptr - bc->buf, bc->out); + bc->buf_ptr = bc->buf; +} + +static void ready_write_buf(output_buffer_t * bc, int amount) { + if (bc->write_len - (bc->buf_ptr - bc->buf) > amount) return; + + if (bc->is_mem) { + int tmp = bc->buf_ptr - bc->buf; + bc->write_len = tmp + amount + PREALLOC_SIZE; + bc->buf = realloc(bc->buf, bc->write_len); + bc->buf_ptr = bc->buf + tmp; + } else { + flush_out_buf(bc); + if (bc->write_len < amount) { + free(bc->buf); + bc->write_len = amount + PREALLOC_SIZE; + bc->buf_ptr = bc->buf = malloc(bc->write_len); + } + } +} + +static void put_bytes(output_buffer_t * bc, int count, uint64_t val) { + ready_write_buf(bc, count); + for(count--; count >= 0; count--){ + *(bc->buf_ptr++) = val >> (8 * count); + } +} + +static output_buffer_t * new_mem_buffer() { + output_buffer_t * bc = malloc(sizeof(output_buffer_t)); + bc->write_len = PREALLOC_SIZE; + bc->is_mem = 1; + bc->file_pos = 0; + bc->buf_ptr = bc->buf = malloc(bc->write_len); + return bc; +} + +static output_buffer_t * new_output_buffer(FILE * out) { + output_buffer_t * bc = new_mem_buffer(); + bc->is_mem = 0; + bc->out = out; + return bc; +} + +static int v_len(uint64_t val) { + int i; + val &= 0x7FFFFFFFFFFFFFFFULL; + for(i=1; val>>(i*7); i++); + return i; +} + +static void put_v(output_buffer_t * bc, uint64_t val) { + int i = v_len(val); + ready_write_buf(bc, i); + for(i = (i-1)*7; i; i-=7) { + *(bc->buf_ptr++) = 0x80 | (val>>i); + } + *(bc->buf_ptr++)= val & 0x7F; +} + +static void put_data(output_buffer_t * bc, int len, const uint8_t * data) { + if (len < PREALLOC_SIZE || bc->is_mem) { + ready_write_buf(bc, len); + memcpy(bc->buf_ptr, data, len); + bc->buf_ptr += len; + } else { + flush_out_buf(bc); + bc->file_pos += fwrite(data, 1, len, bc->out); + } +} + +static void free_out_buffer(output_buffer_t * bc) { + if (!bc) return; + if (!bc->is_mem) flush_out_buf(bc); + free(bc->buf); + free(bc); +} + +// ============ INPUT BUFFER ============== + +typedef struct { + FILE * in; + uint8_t * buf; + uint8_t * buf_ptr; + int write_len; // memory allocated + int read_len; // data in memory + off_t file_pos; + off_t filesize; +} input_buffer_t; + +static void flush_buf(input_buffer_t *bc) { + bc->file_pos += bc->buf_ptr - bc->buf; + bc->read_len -= bc->buf_ptr - bc->buf; + memmove(bc->buf, bc->buf_ptr, bc->read_len); + bc->buf_ptr = bc->buf; +} + +static int ready_read_buf(input_buffer_t * bc, int amount) { + int pos = (bc->buf_ptr - bc->buf); + if (bc->read_len - pos < amount) { + amount += 10; + if (bc->write_len - pos < amount) { + bc->write_len = amount + pos + PREALLOC_SIZE; + bc->buf = realloc(bc->buf, bc->write_len); + bc->buf_ptr = bc->buf + pos; + } + bc->read_len += fread(bc->buf + bc->read_len, 1, amount - (bc->read_len - pos), bc->in); + } + return bc->read_len - (bc->buf_ptr - bc->buf); +} + +static void seek_buf(input_buffer_t * bc, long long pos, int whence) { + if (whence == SEEK_CUR) pos -= bc->read_len - (bc->buf_ptr - bc->buf); + fseek(bc->in, pos, whence); + bc->file_pos = ftell(bc->in); + bc->buf_ptr = bc->buf; + bc->read_len = 0; + if (whence == SEEK_END) bc->filesize = bc->file_pos - pos; +} + +static input_buffer_t * new_input_buffer(FILE * in) { + input_buffer_t * bc = malloc(sizeof(input_buffer_t)); + bc->read_len = 0; + bc->write_len = 0; + bc->file_pos = 0; + bc->filesize = 0; + bc->buf_ptr = bc->buf = NULL; + bc->in = in; + return bc; +} + +static int skip_buffer(input_buffer_t * bc, int len) { + if (ready_read_buf(bc, len) < len) return 1; + bc->buf_ptr += len; + return 0; +} + +static void free_buffer(input_buffer_t * bc) { + if (!bc) return; + free(bc->buf); + free(bc); +} + +static int get_bytes(input_buffer_t * bc, int count, uint64_t * val) { + int i; + if (ready_read_buf(bc, count) < count) return 1; + *val = 0; + for(i = 0; i < count; i++){ + *val = (*val << 8) | *(bc->buf_ptr++); + } + return 0; +} + +static int get_v(input_buffer_t * bc, uint64_t * val) { + int i, len; + *val = 0; + do { + len = ready_read_buf(bc, 16); + for(i = 0; i < len; i++){ + uint8_t tmp= *(bc->buf_ptr++); + *val = (*val << 7) | (tmp & 0x7F); + if (!(tmp & 0x80)) return 0; + } + } while (len >= 16); + return 1; +} + +static int get_data(input_buffer_t * bc, int len, uint8_t * buf) { + int tmp; + tmp = ready_read_buf(bc, len); + len = MIN(len, tmp); + memcpy(buf, bc->buf_ptr, len); + bc->buf_ptr += len; + return len; +} + +#define CHECK(expr) do { int _a; if ((_a = (expr))) return _a; } while(0) +#define GET_V(bc, v) do { uint64_t _tmp; CHECK(get_v((bc), &_tmp)); (v) = _tmp; } while(0) + +static int read_headers(input_buffer_t * in) { + int len = strlen(ID_STRING) + 1; + char str[len]; + uint64_t tmp; + if (get_data(in, len, str) != len) return 1; + if (memcmp(str, ID_STRING, len)) return 1; + CHECK(get_bytes(in, 8, &tmp)); + if (tmp != MAIN_STARTCODE) return 1; + GET_V(in, len); + CHECK(skip_buffer(in, len)); + CHECK(get_bytes(in, 8, &tmp)); + while (tmp == STREAM_STARTCODE) { + GET_V(in, len); + CHECK(skip_buffer(in, len)); + CHECK(get_bytes(in, 8, &tmp)); + } + while (tmp == INFO_STARTCODE) { + GET_V(in, len); + CHECK(skip_buffer(in, len)); + CHECK(get_bytes(in, 8, &tmp)); + } + if (tmp == INDEX_STARTCODE) return 2; + in->buf_ptr -= 8; + return 0; +} + +static int find_copy_index(input_buffer_t * in, output_buffer_t * out, off_t * end) { + uint64_t tmp; + uint64_t idx_len; + int new_idx_len, forward_ptr; + int i, padding; + assert(out->is_mem); + + seek_buf(in, -12, SEEK_END); + CHECK(get_bytes(in, 8, &idx_len)); + *end = in->filesize - idx_len; + if (!*end || *end >= in->filesize) return 2; + seek_buf(in, *end, SEEK_SET); + CHECK(get_bytes(in, 8, &tmp)); + if (tmp != INDEX_STARTCODE) return 2; + + GET_V(in, forward_ptr); + + GET_V(in, tmp); put_v(out, tmp); // max_pts + GET_V(in, tmp); put_v(out, tmp); // syncpoints + + GET_V(in, tmp); // first syncpoint position + + new_idx_len = ((idx_len + 7)/8)*8; + + // paranoia, this should either iterate once or not at all + while ( (v_len(tmp + new_idx_len/8 ) - v_len(tmp )) + + (v_len(forward_ptr + new_idx_len-idx_len) - v_len(forward_ptr)) + > new_idx_len - idx_len) new_idx_len += 8; + + padding = new_idx_len - idx_len; + padding -= (v_len(tmp + new_idx_len/8) - v_len(tmp)); + padding -= (v_len(forward_ptr + new_idx_len-idx_len) - v_len(forward_ptr)); // extreme paranoia, this will be zero + for (i = 0; i < padding; i++) put_bytes(out, 1, 0x80); + put_v(out, tmp + new_idx_len/8); // the new first syncpoint position + printf("%d => %d (%d)\n", (int)tmp, (int)(tmp + new_idx_len/8), new_idx_len); + + idx_len = (in->filesize - 12) - bctello(in); // from where we are, until the index_ptr and checksum, copy everything + if (ready_read_buf(in, idx_len) < idx_len) return 1; + ready_write_buf(out, idx_len); + memcpy(out->buf_ptr, in->buf_ptr, idx_len); + out->buf_ptr += idx_len; + in->buf_ptr += idx_len; + + forward_ptr = out->buf_ptr - out->buf; + forward_ptr += 4 + 8; // checksum and index_ptr + put_bytes(out, 8, 8 + v_len(forward_ptr) + forward_ptr); // index_ptr + put_bytes(out, 4, crc32(out->buf, out->buf_ptr - out->buf)); // checksum + + return 0; +} + +static void put_index(output_buffer_t * bc, output_buffer_t * tmp) { + assert(tmp->is_mem); + + put_bytes(bc, 8, INDEX_STARTCODE); + put_v(bc, tmp->buf_ptr - tmp->buf); // forward_ptr + put_data(bc, tmp->buf_ptr - tmp->buf, tmp->buf); +} + +int main(int argc, char * argv[]) { + FILE * fin = argc>2 ? fopen(argv[1], "rb") : NULL; + FILE * fout = argc>2 ? fopen(argv[2], "wb") : NULL; + input_buffer_t * in; + output_buffer_t * out, * mem = new_mem_buffer(); + off_t end; + if (!fin || !fout) { + fprintf(stderr, "bleh\n"); + return 1; + } + in = new_input_buffer(fin); + out = new_output_buffer(fout); + CHECK(find_copy_index(in, mem, &end)); + + seek_buf(in, 0, SEEK_SET); + CHECK(read_headers(in)); + + put_data(out, bctello(in), in->buf); + put_index(out, mem); + + // copy all data + while (bctello(in) < end) { + int len = MIN(PREALLOC_SIZE, end - bctello(in)); + if (ready_read_buf(in, len) < len) return 1; + put_data(out, len, in->buf_ptr); + in->buf_ptr += len; + flush_buf(in); + printf("%d\r", (int)bctello(in)); + } + put_index(out, mem); + + free_buffer(in); + free_out_buffer(out); + free_out_buffer(mem); + + fclose(fin); + fclose(fout); + + return 0; +}