void chpl_mem_layerInit(void) { void* heap_base; size_t heap_size; chpl_comm_desired_shared_heap(&heap_base, &heap_size); if (heap_base != NULL && heap_size == 0) chpl_internal_error("if heap address is specified, size must be also"); // // Do a first allocation, to allow tcmalloc to set up its internal // management structures. // { void* p; if ((p = tc_malloc(1)) == NULL) chpl_internal_error("cannot init heap: tc_malloc() failed"); tc_free(p); } // // Initialize our tcmalloc system allocator. // tcmallocChapelInit_c(heap_base, heap_size); // // If the heap has to come from the memory supplied to us (say, in // order that the comm layer be able to depend on all allocations // having come from it), use up all the system memory tcmalloc had // acquired before we set up our own system allocator just now. // All allocations after this will come from the memory supplied // to us. // // Note that this can waste up to twice INITIAL_USE_UP_SIZE bytes // of the memory supplied to us, plus overhead. // if (heap_base != NULL) { #define INITIAL_USE_UP_SIZE ((size_t) 4 * 1024) size_t size; char* p; for (size = INITIAL_USE_UP_SIZE; size > 0; size /= 2) { do { p = tc_malloc(size); } while (p != NULL && (p < (char*) heap_base || p > (char*) heap_base + heap_size)); #undef INITIAL_USE_UP_SIZE } } }
static int sdlview_init(TCModuleInstance *self, uint32_t features) { int err = 0; SDLPrivateData *pd = NULL; TC_MODULE_SELF_CHECK(self, "init"); TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features); err = SDL_Init(SDL_INIT_VIDEO); if (err) { tc_log_error(MOD_NAME, "SDL initialization failed: %s", SDL_GetError()); return TC_ERROR; } pd = tc_malloc(sizeof(SDLPrivateData)); if (pd == NULL) { tc_log_error(MOD_NAME, "init: out of memory!"); return TC_ERROR; } pd->surface = NULL; pd->overlay = NULL; pd->w = 0; pd->h = 0; self->userdata = pd; if (verbose) { tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); } return TC_OK; }
TCGlob *tc_glob_open(const char *pattern, uint32_t flags) { TCGlob *tcg = NULL; flags = GLOB_ERR; /* flags intentionally overridden */ if (pattern != NULL && strlen(pattern) > 0) { tcg = tc_malloc(sizeof(TCGlob)); if (tcg != NULL) { int err = 0; tcg->pattern = NULL; err = glob(pattern, flags, NULL, &(tcg->glob)); switch (err) { case GLOB_NOMATCH: tcg->pattern = tc_strdup(pattern); // XXX tcg->current = -1; break; case GLOB_NOERROR: tcg->current = 0; break; default: /* any other error: clean it up */ tc_log_error(__FILE__, "internal glob failed (code=%i)", err); tc_free(tcg); tcg = NULL; } } } return tcg; }
static int tc_y4m_init(TCModuleInstance *self, uint32_t features) { Y4MPrivateData *pd = NULL; TC_MODULE_SELF_CHECK(self, "init"); TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features); pd = tc_malloc(sizeof(Y4MPrivateData)); if (pd == NULL) { return TC_ERROR; } pd->width = 0; pd->height = 0; pd->fd_vid = -1; y4m_init_stream_info(&(pd->streaminfo)); /* frameinfo will be initialized at each multiplex call */ if (verbose) { tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); } self->userdata = pd; return TC_OK; }
static int faac_init(TCModuleInstance *self, uint32_t features) { PrivateData *pd; TC_MODULE_SELF_CHECK(self, "init"); TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features); self->userdata = pd = tc_malloc(sizeof(PrivateData)); if (!pd) { tc_log_error(MOD_NAME, "init: out of memory!"); return TC_ERROR; } pd->handle = 0; pd->audiobuf = NULL; pd->need_flush = TC_FALSE; /* FIXME: shouldn't this test a specific flag? */ if (verbose) { tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); if (verbose >= TC_INFO) { char *id, *copyright; faacEncGetVersion(&id, ©right); tc_log_info(MOD_NAME, "Using FAAC %s", id); } } return TC_OK; }
static int write_tmpfile(char* header, char* content, int content_size, int slot_id){ FILE* tmp = NULL; int i = 0; char* filename = NULL; filename = tc_malloc(sizeof(char)*(strlen(TMP_FILE) + TMP_STRING_SIZE)); if (!filename){ tc_log_error(MOD_NAME, "Out of memory !!!"); return -1; } if (verbose & TC_DEBUG) tc_log_info(MOD_NAME, "Temporary filename correctly allocated."); tc_snprintf(filename, strlen(TMP_FILE) + TMP_STRING_SIZE, "%s-%d.tmp", TMP_FILE, slot_id); tmp = fopen(filename, "w"); if (!tmp){ tc_log_error(MOD_NAME, "Cannot write temporary file !"); return -1; } for(i=0; i<strlen(header); i++) fputc(header[i], tmp); for(i=0; i< content_size; i++) fputc(content[i], tmp); fclose(tmp); free(filename); return 0; }
file_queue_node *enqueue_file(file_queue *queue, const char *filename) { file_queue_node *node = (file_queue_node *)tc_malloc(sizeof(file_queue_node)); node->next = NULL; node->prev = NULL; node->match_lines = NULL; node->searched = false; node->matched = false; strcpy(node->filename, filename); if (queue->first) { node->prev = queue->last; queue->last->next = node; queue->last = node; if (!queue->current_for_search) { queue->current_for_search = node; } } else { queue->first = node; queue->last = node; queue->current_for_search = node; } return node; }
static void deNoise(unsigned char *Frame, // mpi->planes[x] unsigned char *FrameDest, // dmpi->planes[x] unsigned int *LineAnt, // vf->priv->Line (width bytes) unsigned short **FrameAntPtr, int W, int H, int sStride, int dStride, int *Horizontal, int *Vertical, int *Temporal) { int X, Y; int sLineOffs = 0, dLineOffs = 0; unsigned int PixelAnt; int PixelDst; unsigned short* FrameAnt=(*FrameAntPtr); if(!FrameAnt){ (*FrameAntPtr)=FrameAnt=tc_malloc(W*H*sizeof(unsigned short)); for (Y = 0; Y < H; Y++){ unsigned short* dst=&FrameAnt[Y*W]; unsigned char* src=Frame+Y*sStride; for (X = 0; X < W; X++) dst[X]=src[X]<<8; } } /* First pixel has no left nor top neightbour. Only previous frame */ LineAnt[0] = PixelAnt = Frame[0]<<16; PixelDst = LowPassMul(FrameAnt[0]<<8, PixelAnt, Temporal); FrameAnt[0] = ((PixelDst+0x1000007F)/256); FrameDest[0]= ((PixelDst+0x10007FFF)/65536); /* Fist line has no top neightbour. Only left one for each pixel and * last frame */ for (X = 1; X < W; X++){ LineAnt[X] = PixelAnt = LowPassMul(PixelAnt, Frame[X]<<16, Horizontal); PixelDst = LowPassMul(FrameAnt[X]<<8, PixelAnt, Temporal); FrameAnt[X] = ((PixelDst+0x1000007F)/256); FrameDest[X]= ((PixelDst+0x10007FFF)/65536); } for (Y = 1; Y < H; Y++){ unsigned int PixelAnt; unsigned short* LinePrev=&FrameAnt[Y*W]; sLineOffs += sStride, dLineOffs += dStride; /* First pixel on each line doesn't have previous pixel */ PixelAnt = Frame[sLineOffs]<<16; LineAnt[0] = LowPassMul(LineAnt[0], PixelAnt, Vertical); PixelDst = LowPassMul(LinePrev[0]<<8, LineAnt[0], Temporal); LinePrev[0] = ((PixelDst+0x1000007F)/256); FrameDest[dLineOffs]= ((PixelDst+0x10007FFF)/65536); for (X = 1; X < W; X++){ int PixelDst; /* The rest are normal */ PixelAnt = LowPassMul(PixelAnt, Frame[sLineOffs+X]<<16, Horizontal); LineAnt[X] = LowPassMul(LineAnt[X], PixelAnt, Vertical); PixelDst = LowPassMul(LinePrev[X]<<8, LineAnt[X], Temporal); LinePrev[X] = ((PixelDst+0x1000007F)/256); FrameDest[dLineOffs+X]= ((PixelDst+0x10007FFF)/65536); } } }
match_line_list *create_match_line_list() { match_line_list *list = (match_line_list *)tc_malloc(sizeof(match_line_list)); list->first = NULL; list->last = NULL; list->max_line_no = 1; return list; }
TCList *tc_list_new(int usecache) { TCList *L = tc_malloc(sizeof(TCList)); if (L) { tc_list_init(L, usecache); } return L; }
file_queue *create_file_queue() { file_queue *queue = (file_queue *)tc_malloc(sizeof(file_queue)); queue->first = NULL; queue->last = NULL; queue->current_for_search = NULL; return queue; }
int tc_ogg_dup_packet(ogg_packet *dst, const ogg_packet *src) { int ret = TC_ERROR; ac_memcpy(dst, src, sizeof(ogg_packet)); dst->packet = tc_malloc(src->bytes); if (dst->packet) { ac_memcpy(dst->packet, src->packet, src->bytes); ret = TC_OK; } return ret; }
int tc_list_insert_dup(TCList *L, int pos, void *data, size_t size) { int ret = TC_ERROR; void *mem = tc_malloc(size); if (mem) { memcpy(mem, data, size); ret = tc_list_insert(L, pos, mem); if (ret == TC_ERROR) { tc_free(mem); } } return ret; }
seq_list_t *seq_register(int id) { /* objectives: =========== register new seq allocate space for new seq and establish backward reference */ seq_list_t *ptr; pthread_mutex_lock(&seq_list_lock); // retrive a valid pointer from the pool if((ptr = tc_malloc(sizeof(seq_list_t))) == NULL) { pthread_mutex_unlock(&seq_list_lock); return(NULL); } memset(ptr, 0, sizeof(seq_list_t)); ptr->status = BUFFER_EMPTY; ptr->next = NULL; ptr->prev = NULL; ptr->id = id; if(seq_list_tail != NULL) { seq_list_tail->next = ptr; ptr->prev = seq_list_tail; } seq_list_tail = ptr; /* first seq registered must set seq_list_head */ if(seq_list_head == NULL) seq_list_head = ptr; pthread_mutex_unlock(&seq_list_lock); return(ptr); }
/** * calulcates the cleaned maximum and minimum of an array of transforms, * considerung only x and y * It cuts off the upper and lower x-th percentil * * Parameters: * transforms: array of transforms. * len: length of array * percentil: the x-th percentil to cut off * min: pointer to min (return value) * max: pointer to max (return value) * Return value: * call by reference in min and max * Preconditions: * len>0, 0<=percentil<50 * Side effects: * only on min and max */ void cleanmaxmin_xy_transform(const Transform* transforms, int len, int percentil, Transform* min, Transform* max){ Transform* ts = tc_malloc(sizeof(Transform) * len); int cut = len * percentil / 100; memcpy(ts, transforms, sizeof(Transform) * len); qsort(ts,len, sizeof(Transform), cmp_trans_x); min->x = ts[cut].x; max->x = ts[len-cut-1].x; qsort(ts, len, sizeof(Transform), cmp_trans_y); min->y = ts[cut].y; max->y = ts[len-cut-1].y; tc_free(ts); }
/** * median_xy_transform: calulcates the median of an array * of transforms, considering only x and y * * Parameters: * transforms: array of transforms. * len: length of array * Return value: * A new transform with x and y beeing the median of * all transforms. alpha and other fields are 0. * Preconditions: * len>0 * Side effects: * None */ Transform median_xy_transform(const Transform* transforms, int len) { Transform* ts = tc_malloc(sizeof(Transform) * len); Transform t; memcpy(ts,transforms, sizeof(Transform)*len ); int half = len/2; qsort(ts, len, sizeof(Transform), cmp_trans_x); t.x = len % 2 == 0 ? ts[half].x : (ts[half].x + ts[half+1].x)/2; qsort(ts, len, sizeof(Transform), cmp_trans_y); t.y = len % 2 == 0 ? ts[half].y : (ts[half].y + ts[half+1].y)/2; t.alpha = 0; t.zoom = 0; t.extra = 0; tc_free(ts); return t; }
/** * cleanmean_xy_transform: calulcates the cleaned mean of an array * of transforms, considering only x and y * * Parameters: * transforms: array of transforms. * len: length of array * Return value: * A new transform with x and y beeing the cleaned mean * (meaning upper and lower pentile are removed) of * all transforms. alpha and other fields are 0. * Preconditions: * len>0 * Side effects: * None */ Transform cleanmean_xy_transform(const Transform* transforms, int len) { Transform* ts = tc_malloc(sizeof(Transform) * len); Transform t = null_transform(); int i, cut = len / 5; memcpy(ts, transforms, sizeof(Transform) * len); qsort(ts,len, sizeof(Transform), cmp_trans_x); for (i = cut; i < len - cut; i++){ // all but cutted t.x += ts[i].x; } qsort(ts, len, sizeof(Transform), cmp_trans_y); for (i = cut; i < len - cut; i++){ // all but cutted t.y += ts[i].y; } tc_free(ts); return mult_transform(&t, 1.0 / (len - (2.0 * cut))); }
static int tc_x11_init(TCModuleInstance *self, uint32_t features) { TCX11PrivateData *priv = NULL; TC_MODULE_SELF_CHECK(self, "init"); TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features); if (verbose) { tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); } priv = tc_malloc(sizeof(TCX11PrivateData)); if (priv == NULL) { return TC_ERROR; } self->userdata = priv; return TC_OK; }
static int nuv_init(TCModuleInstance *self, uint32_t features) { PrivateData *pd; TC_MODULE_SELF_CHECK(self, "init"); TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features); self->userdata = pd = tc_malloc(sizeof(PrivateData)); if (!pd) { tc_log_error(MOD_NAME, "init: out of memory!"); return TC_ERROR; } pd->fd = -1; pd->dec_initted = 0; if (verbose) { tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); } return TC_OK; }
static int raw_init(TCModuleInstance *self, uint32_t features) { RawPrivateData *pd = NULL; TC_MODULE_SELF_CHECK(self, "init"); TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features); pd = tc_malloc(sizeof(RawPrivateData)); if (pd == NULL) { return TC_ERROR; } pd->fd_aud = -1; pd->fd_vid = -1; if (verbose) { tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); } self->userdata = pd; return TC_OK; }
static int doublefps_init(TCModuleInstance *self, uint32_t features) { DfpsPrivateData *pd; vob_t *vob = tc_get_vob(); TC_MODULE_SELF_CHECK(self, "init"); TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features); self->userdata = pd = tc_malloc(sizeof(DfpsPrivateData)); if (!pd) { tc_log_error(MOD_NAME, "init: out of memory!"); return TC_ERROR; } pd->topfirst = -1; pd->fullheight = 0; pd->have_first_frame = pd->saved_width = pd->saved_height = 0; /* FIXME: we need a proper way for filters to tell the core that * they're changing the export parameters */ if (!(vob->export_attributes & (TC_EXPORT_ATTRIBUTE_FPS | TC_EXPORT_ATTRIBUTE_FRC)) ) { vob->ex_fps *= 2; switch (vob->ex_frc) { case 3: vob->ex_frc = 6; break; case 4: vob->ex_frc = 7; break; case 5: vob->ex_frc = 8; break; case 10: vob->ex_frc = 11; break; case 12: vob->ex_frc = 2; break; case 13: vob->ex_frc = 5; break; default: vob->ex_frc = 0; break; } } if (verbose) { tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); } return TC_OK; }
void *user_malloc(int size, uint32_t handle, uint32_t *op_time, void **memaddress) { g_memory_usage += size*0.9; // XXX: *0.9 is bogus, should be just size. for plot testing purposes! TIMER_DECL; TIMER_START; void *ptr = tc_malloc(size); TIMER_END; if (op_time) *op_time = TIMER_ELAPSED; if (ptr == NULL) return ptr; //printf("|| h == (void *)0x%X // MALLOC, heap start %x, heap end %x\n", (uint32_t)ptr, (uint32_t)g_heap, (uint32_t)g_heap_end); g_handles[ptr] = size; g_handle_pointer[ptr] = handle; if (g_count.find(ptr) == g_count.end()) g_count[ptr] = 1; else { g_count[ptr] += 1; if (g_count[ptr] > 1) fprintf(stderr, "Double malloc for handle %d\n", handle); // FIXME: this test should be here. } #ifdef DEBUG //sanity(); #endif g_malloc++; if (memaddress != NULL) *memaddress = (void *)((ptr_t)ptr); return ptr; }
void* operator new[](size_t size, const std::nothrow_t& nt) { return tc_malloc(size); }
ZoomInfo *zoom_init(int old_w, int old_h, int new_w, int new_h, int Bpp, int old_stride, int new_stride, TCVZoomFilter filter) { ZoomInfo *zi; struct clist *x_contrib = NULL, *y_contrib = NULL; /* Sanity check */ if (old_w <= 0 || old_h <= 0 || new_w <= 0 || new_h <= 0 || Bpp <= 0 || old_stride <= 0 || new_stride <= 0) return NULL; /* Allocate structure */ zi = tc_malloc(sizeof(*zi)); if (!zi) return NULL; /* Set up scalar members, and check filter value */ zi->old_w = old_w; zi->old_h = old_h; zi->new_w = new_w; zi->new_h = new_h; zi->Bpp = Bpp; zi->old_stride = old_stride; zi->new_stride = new_stride; switch (filter) { case TCV_ZOOM_BOX: zi->filter = box_filter; zi->fwidth = box_support; break; case TCV_ZOOM_TRIANGLE: zi->filter = triangle_filter; zi->fwidth = triangle_support; break; case TCV_ZOOM_HERMITE: zi->filter = hermite_filter; zi->fwidth = hermite_support; break; case TCV_ZOOM_BELL: zi->filter = bell_filter; zi->fwidth = bell_support; break; case TCV_ZOOM_B_SPLINE: zi->filter = B_spline_filter; zi->fwidth = B_spline_support; break; case TCV_ZOOM_MITCHELL: zi->filter = mitchell_filter; zi->fwidth = mitchell_support; break; case TCV_ZOOM_LANCZOS3: zi->filter = lanczos3_filter; zi->fwidth = lanczos3_support; break; case TCV_ZOOM_CUBIC_KEYS4: zi->filter = cubic_keys4_filter; zi->fwidth = cubic_keys4_support; break; case TCV_ZOOM_SINC8: zi->filter = sinc8_filter; zi->fwidth = sinc8_support; break; default: free(zi); return NULL; } /* Generate contributor lists and allocate temporary image buffer */ zi->x_contrib = NULL; zi->y_contrib = NULL; zi->tmpimage = tc_malloc(new_w * old_h * Bpp); if (!zi->tmpimage) goto error_out; if (old_w != new_w) { x_contrib = gen_contrib(old_w, new_w, Bpp, zi->filter, zi->fwidth); if (!x_contrib) goto error_out; } if (old_h != new_h) { /* Calculate the correct stride--if the width isn't changing, * this will just be old_stride */ int stride = (old_w==new_w) ? old_stride : Bpp*new_w; y_contrib = gen_contrib(old_h, new_h, stride, zi->filter, zi->fwidth); if (!y_contrib) goto error_out; } /* Convert contributor lists into flat arrays and fixed-point values. * The flat array consists of a contributor count plus two values per * contributor (index and fixed-point weight) for each output pixel. * Note that for the horizontal direction, we make `Bpp' copies of the * contributors, adjusting the offset for each byte of the pixel. */ if (x_contrib) { int count = 0, i; int32_t *ptr; for (i = 0; i < new_w; i++) count += 1 + 2 * x_contrib[i].n; zi->x_contrib = tc_malloc(sizeof(int32_t) * count * Bpp); if (!zi->x_contrib) goto error_out; for (ptr = zi->x_contrib, i = 0; i < new_w * Bpp; i++) { int j; *ptr++ = x_contrib[i/Bpp].n; for (j = 0; j < x_contrib[i/Bpp].n; j++) { *ptr++ = x_contrib[i/Bpp].list[j].pixel + i%Bpp; *ptr++ = DOUBLE_TO_FIXED(x_contrib[i/Bpp].list[j].weight); } } /* Free original contributor list */ for (i = 0; i < new_w; i++) free(x_contrib[i].list); free(x_contrib); x_contrib = NULL; } if (y_contrib) { int count = 0, i; int32_t *ptr; for (i = 0; i < new_h; i++) count += 1 + 2 * y_contrib[i].n; zi->y_contrib = tc_malloc(sizeof(int32_t) * count); if (!zi->y_contrib) goto error_out; for (ptr = zi->y_contrib, i = 0; i < new_h; i++) { int j; *ptr++ = y_contrib[i].n; for (j = 0; j < y_contrib[i].n; j++) { *ptr++ = y_contrib[i].list[j].pixel; *ptr++ = DOUBLE_TO_FIXED(y_contrib[i].list[j].weight); } } for (i = 0; i < new_h; i++) free(y_contrib[i].list); free(y_contrib); y_contrib = NULL; } /* Done */ return zi; error_out: { if (x_contrib) { int i; for (i = 0; i < new_w; i++) free(x_contrib[i].list); free(x_contrib); } if (y_contrib) { int i; for (i = 0; i < new_w; i++) free(x_contrib[i].list); free(x_contrib); } zoom_free(zi); return NULL; } }
void* operator new[](size_t size) { return tc_malloc(size); }
void decode_mov(decode_t *decode) { quicktime_t *qt_handle=NULL; unsigned char **p_raw_buffer; char *p_v_codec=NULL,*p_a_codec=NULL,*p_buffer=NULL,*p_tmp=NULL; int s_width=0,s_height=0,s_channel=0,s_bits=0,s_buff_size=0,s_audio_size=0,s_video_size=0,s_sample=0; int s_cont,s_frames; double s_fps=0; long s_audio_rate,s_qt_pos; uint16_t *p_mask1, *p_mask2; char msgbuf[TC_BUF_MIN]; qt_handle = quicktime_open((char * )decode->name, 1, 0); if (qt_handle == NULL) { QT_ABORT("can't open quicktime!"); } quicktime_set_preload(qt_handle, 10240000); s_fps = quicktime_frame_rate(qt_handle, 0); if (decode->format == TC_CODEC_PCM) { if (quicktime_audio_tracks(qt_handle) == 0) { QT_ABORT("no audio track in quicktime found!"); } s_channel = quicktime_track_channels(qt_handle, 0); s_audio_rate = quicktime_sample_rate(qt_handle, 0); s_bits = quicktime_audio_bits(qt_handle, 0); s_audio_size = quicktime_audio_length(qt_handle,0); p_a_codec = quicktime_audio_compressor(qt_handle, 0); if (decode->frame_limit[1] < s_audio_size) { s_audio_size = decode->frame_limit[1] - decode->frame_limit[0]; } else { s_audio_size -= decode->frame_limit[0]; } if (decode->verbose) { tc_log_info(__FILE__, "Audio codec=%s, rate=%ld Hz, bits=%d, channels=%d", p_a_codec, s_audio_rate, s_bits, s_channel); } if ((s_bits != 8) && (s_bits != 16)) { tc_snprintf(msgbuf, sizeof(msgbuf), "unsupported %d bit rate" " in quicktime!", s_bits); QT_ABORT(msgbuf); } if (s_channel > 2) { tc_snprintf(msgbuf, sizeof(msgbuf), "too many audio tracks " "(%d) found in quicktime!", s_channel); QT_ABORT(msgbuf); } if (strlen(p_a_codec) == 0) { QT_ABORT("unsupported codec (empty!) in quicktime!"); } if (quicktime_supported_audio(qt_handle, 0) != 0) { s_qt_pos = quicktime_audio_position(qt_handle,0); s_sample = (1.00 * s_channel * s_bits *s_audio_rate)/(s_fps * 8); s_buff_size = s_sample * sizeof(uint16_t); p_buffer = tc_malloc(s_buff_size); if (s_bits == 16) s_sample /= 2; if (s_channel == 1) { p_mask1=(uint16_t *)p_buffer; quicktime_set_audio_position(qt_handle, s_qt_pos + decode->frame_limit[0], 0); for (; s_audio_size > 0; s_audio_size -= s_sample) { if (quicktime_decode_audio(qt_handle, p_mask1, NULL, s_sample, 0) < 0) { QT_ABORT("error reading quicktime audio frame"); } QT_WRITE(decode->fd_out, p_buffer, s_buff_size); } } else { s_sample /= 2; p_mask1 = (uint16_t *)p_buffer; p_mask2 = tc_malloc(s_sample * sizeof(uint16_t)); s_qt_pos += decode->frame_limit[0]; quicktime_set_audio_position(qt_handle, s_qt_pos, 0); for (; s_audio_size > 0; s_audio_size -= s_sample) { if (quicktime_decode_audio(qt_handle, p_mask1, NULL, s_sample, 0) < 0) { QT_ABORT("error reading quicktime audio frame"); } quicktime_set_audio_position(qt_handle, s_qt_pos, 0); if (quicktime_decode_audio(qt_handle,p_mask2, NULL,s_sample, 1) < 0) { QT_ABORT("error reading quicktime audio frame"); } for (s_cont = s_sample - 1; s_cont >= 0; s_cont--) p_mask1[s_cont<<1] = p_mask1[s_cont]; for (s_cont = 0; s_cont < s_sample; s_cont++) p_mask1[1+(s_cont<<1)] = p_mask2[s_cont]; s_qt_pos += s_sample; QT_WRITE(decode->fd_out, p_buffer, s_buff_size >> 1); } free(p_mask2); } free(p_buffer); } #if !defined(LIBQUICKTIME_000904) else if ((strcasecmp(p_a_codec, QUICKTIME_RAW) == 0)
p_mask1[s_cont<<1] = p_mask1[s_cont]; for (s_cont = 0; s_cont < s_sample; s_cont++) p_mask1[1+(s_cont<<1)] = p_mask2[s_cont]; s_qt_pos += s_sample; QT_WRITE(decode->fd_out, p_buffer, s_buff_size >> 1); } free(p_mask2); } free(p_buffer); } #if !defined(LIBQUICKTIME_000904) else if ((strcasecmp(p_a_codec, QUICKTIME_RAW) == 0) || (strcasecmp(p_a_codec, QUICKTIME_TWOS) == 0)) { s_sample = (1.00 * s_channel * s_bits *s_audio_rate)/(s_fps * 8); s_buff_size = s_sample * sizeof(uint16_t); p_buffer = tc_malloc(s_buff_size); s_qt_pos = quicktime_audio_position(qt_handle, 0); quicktime_set_audio_position(qt_handle, s_qt_pos + decode->frame_limit[0], 0); for (; s_audio_size > 0; s_audio_size -= s_buff_size) { if (quicktime_read_audio(qt_handle,p_buffer, s_buff_size, 0) < 0) { QT_ABORT("error reading quicktime audio frame"); } QT_WRITE(decode->fd_out, p_buffer, s_buff_size); } quicktime_close(qt_handle); free(p_buffer); } #endif else { tc_snprintf(msgbuf, sizeof(msgbuf), "quicktime audio codec '%s'" " not supported!", p_a_codec);
#include <dirent.h> #ifndef DIR_NAME #define DIR_NAME "./knowledge/" #endif #define FILE_BUFFER 1024 TEXTCAT_SAVE(default) { uchar * fname, * content; long i, ret, offset; int fd; fname = tc_malloc(strlen(id) + strlen(DIR_NAME) + 2); sprintf(fname, "%s/%s", DIR_NAME, id); mkdir(DIR_NAME, 0777); fd = open(fname, O_CREAT | O_TRUNC | O_WRONLY, 0644); if (fd == -1) { return TC_FALSE; } content = tc_malloc(FILE_BUFFER); if (content == NULL) { return TC_FALSE; } /* sort by freq */ textcat_ngram_sort_by_freq(result);
void probe_ogg(info_t *ipipe) { ogg_sync_state sync; ogg_page page; ogg_packet pack; char *buf; int nread, np, sno, nvtracks = 0, natracks = 0, i, idx; //int endofstream = 0, k, n; struct demux_t streams[MAX_AUDIO_TRACKS + MAX_VIDEO_TRACKS]; int fdin = -1; char vid_codec[5]; ogm_stream_header *sth; fdin = ipipe->fd_in; if (fdin == -1) { tc_log_error(__FILE__, "Could not open file."); goto ogg_out; } ipipe->probe_info->magic=TC_MAGIC_OGG; memset(streams, 0, sizeof(streams)); for (i = 0; i < (MAX_AUDIO_TRACKS + MAX_VIDEO_TRACKS); i++) streams[i].serial = -1; ogg_sync_init(&sync); while (1) { np = ogg_sync_pageseek(&sync, &page); if (np < 0) { tc_log_error(__FILE__, "ogg_sync_pageseek failed"); goto ogg_out; } if (np == 0) { buf = ogg_sync_buffer(&sync, BLOCK_SIZE); if (!buf) { tc_log_error(__FILE__, "ogg_sync_buffer failed"); goto ogg_out; } if ((nread = read(fdin, buf, BLOCK_SIZE)) <= 0) { } ogg_sync_wrote(&sync, nread); continue; } if (!ogg_page_bos(&page)) { break; } else { ogg_stream_state sstate; vorbis_info *inf = tc_malloc (sizeof(vorbis_info)); vorbis_comment *com = tc_malloc (sizeof(vorbis_comment)); if (!inf || !com) { tc_log_error(__FILE__, "Out of Memory at %d", __LINE__); goto ogg_out; } sno = ogg_page_serialno(&page); if (ogg_stream_init(&sstate, sno)) { tc_log_error(__FILE__, "ogg_stream_init failed"); goto ogg_out; } ogg_stream_pagein(&sstate, &page); ogg_stream_packetout(&sstate, &pack); switch (ogm_packet_type(pack)) { case Vorbis: vorbis_info_init(inf); vorbis_comment_init(com); if(vorbis_synthesis_headerin(inf, com, &pack) < 0) { tc_log_warn(__FILE__, "Could not decode vorbis header " "packet - invalid vorbis stream ()"); } else { #ifdef OGM_DEBUG tc_log_msg(__FILE__, "(a%d/%d) Vorbis audio; " "rate: %ldHz, channels: %d, bitrate %3.2f kb/s", natracks + 1, natracks + nvtracks + 1, inf->rate, inf->channels, (double)inf->bitrate_nominal/1000.0); #endif ipipe->probe_info->track[natracks].samplerate = inf->rate; ipipe->probe_info->track[natracks].chan = inf->channels; ipipe->probe_info->track[natracks].bits = 0; /* XXX --tibit*/ ipipe->probe_info->track[natracks].format = TC_CODEC_VORBIS; ipipe->probe_info->track[natracks].bitrate = (double)inf->bitrate_nominal/1000.0; ipipe->probe_info->track[natracks].tid=natracks; if(ipipe->probe_info->track[natracks].chan>0) ++ipipe->probe_info->num_tracks; streams[natracks].serial = sno; streams[natracks].vorbis = 1; ac_memcpy(&streams[natracks].state, &sstate, sizeof(sstate)); natracks++; } break; #ifdef HAVE_THEORA case Theora: { theora_info ti; theora_comment tc; theora_decode_header(&ti, &tc, &pack); ipipe->probe_info->width = ti.width; ipipe->probe_info->height = ti.height; ipipe->probe_info->fps = (double)ti.fps_numerator/ti.fps_denominator; tc_frc_code_from_ratio(&(ipipe->probe_info->frc), ti.fps_numerator, ti.fps_denominator); ipipe->probe_info->codec=TC_CODEC_THEORA; idx = natracks + MAX_AUDIO_TRACKS; streams[idx].serial = sno; ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate)); nvtracks++; break; } #endif case DirectShow: if ((*(int32_t*)(pack.packet+96) == 0x05589f80) && (pack.bytes >= 184)) { tc_log_warn(__FILE__, "(v%d/%d) Found old video " "header. Not supported.", nvtracks + 1, natracks + nvtracks + 1); } else if (*(int32_t*)pack.packet+96 == 0x05589F81) { tc_log_warn(__FILE__, "(a%d/%d) Found old audio " "header. Not supported.", natracks + 1, natracks + nvtracks + 1); } break; case StreamHeader: sth = (ogm_stream_header *)(pack.packet + 1); if (!strncmp(sth->streamtype, "video", 5)) { #ifdef OGM_DEBUG unsigned long codec; codec = (sth->subtype[0] << 24) + (sth->subtype[1] << 16) + (sth->subtype[2] << 8) + sth->subtype[3]; tc_log_msg(__FILE__, "(v%d/%d) video; fps: %.3f width height: %dx%d " "codec: %p (%c%c%c%c)", nvtracks + 1, natracks + nvtracks + 1, (double)10000000 / (double)sth->time_unit, sth->sh.video.width, sth->sh.video.height, (void *)codec, sth->subtype[0], sth->subtype[1], sth->subtype[2], sth->subtype[3]); #endif vid_codec[0] = sth->subtype[0]; vid_codec[1] = sth->subtype[1]; vid_codec[2] = sth->subtype[2]; vid_codec[3] = sth->subtype[3]; vid_codec[4] = '\0'; //ipipe->probe_info->frames = AVI_video_frames(avifile); ipipe->probe_info->width = sth->sh.video.width; ipipe->probe_info->height = sth->sh.video.height; ipipe->probe_info->fps = (double)10000000 / (double)sth->time_unit; tc_frc_code_from_value(&(ipipe->probe_info->frc), ipipe->probe_info->fps); ipipe->probe_info->codec=TC_CODEC_UNKNOWN; // gets rewritten if(strlen(vid_codec)==0) { ipipe->probe_info->codec=TC_CODEC_RGB24; } else { if(strcasecmp(vid_codec,"dvsd")==0) ipipe->probe_info->codec=TC_CODEC_DV; if(strcasecmp(vid_codec,"DIV3")==0) ipipe->probe_info->codec=TC_CODEC_DIVX3; if(strcasecmp(vid_codec,"DIVX")==0) ipipe->probe_info->codec=TC_CODEC_DIVX4; if(strcasecmp(vid_codec,"DX50")==0) ipipe->probe_info->codec=TC_CODEC_DIVX5; if(strcasecmp(vid_codec,"XVID")==0) ipipe->probe_info->codec=TC_CODEC_XVID; if(strcasecmp(vid_codec,"MJPG")==0) ipipe->probe_info->codec=TC_CODEC_MJPEG; } idx = natracks + MAX_AUDIO_TRACKS; streams[idx].serial = sno; ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate)); nvtracks++; } else if (!strncmp(sth->streamtype, "audio", 5)) { int codec; char buf[5]; ac_memcpy(buf, sth->subtype, 4); buf[4] = 0; codec = strtoul(buf, NULL, 16); #ifdef OGM_DEBUG tc_log_msg(__FILE__, "(a%d/%d) codec: %d (0x%04x) (%s) bits per " "sample: %d channels: %hd samples per second: %ld " "avgbytespersec: %hd blockalign: %d", natracks + 1, natracks + nvtracks + 1, codec, codec, codec == 0x1 ? "PCM" : codec == 55 ? "MP3" : codec == 0x55 ? "MP3" : codec == 0x2000 ? "AC3" : "unknown", sth->bits_per_sample, sth->sh.audio.channels, (long)sth->samples_per_unit, sth->sh.audio.avgbytespersec, sth->sh.audio.blockalign); #endif idx = natracks; ipipe->probe_info->track[natracks].samplerate = sth->samples_per_unit; ipipe->probe_info->track[natracks].chan = sth->sh.audio.channels; ipipe->probe_info->track[natracks].bits = (sth->bits_per_sample<4)?sth->bits_per_sample*8:sth->bits_per_sample; ipipe->probe_info->track[natracks].format = codec; ipipe->probe_info->track[natracks].bitrate = 0; ipipe->probe_info->track[natracks].tid=natracks; if(ipipe->probe_info->track[natracks].chan>0) ++ipipe->probe_info->num_tracks; streams[idx].serial = sno; ac_memcpy(&streams[idx].state, &sstate, sizeof(sstate)); natracks++; } else { tc_log_warn(__FILE__, "(%d) found new header of unknown/" "unsupported type\n", nvtracks + natracks + 1); } break; case none: tc_log_warn(__FILE__, "OGG stream %d is of an unknown type " "(bad header?)", nvtracks + natracks + 1); break; } /* switch type */ free(inf); free(com); ogg_stream_clear(&sstate); } /* beginning of page */ } /* while (1) */ ogg_out: //close(fdin); return; }
int tc_filter(frame_list_t *ptr_, char *options) { vframe_list_t *ptr = (vframe_list_t *)ptr_; static vob_t *vob=NULL; /* FIXME: these use the filter ID as an index--the ID can grow * arbitrarily large, so this needs to be fixed */ static int cdiff[100], ldiff[100], range[100]; static float strength[100]; int instance = ptr->filter_id; //---------------------------------- // // filter print configure // //---------------------------------- if(ptr->tag & TC_FILTER_GET_CONFIG) { char buf[32]; optstr_filter_desc (options, MOD_NAME, MOD_CAP, MOD_VERSION, MOD_AUTHOR, "VYEM", "1"); // buf, name, comment, format, val, from, to tc_snprintf (buf, 32, "%.2f", strength[instance]); optstr_param (options, "strength", "Blending factor", "%f", buf, "0.0", "0.9"); tc_snprintf (buf, 32, "%d", cdiff[instance]); optstr_param (options, "cdiff", "Max difference in chroma values", "%d", buf, "0", "16"); tc_snprintf (buf, 32, "%d", ldiff[instance]); optstr_param (options, "ldiff", "Max difference in luma value", "%d", buf, "0", "16"); tc_snprintf (buf, 32, "%d", range[instance]); optstr_param (options, "range", "Search Range", "%d", buf, "0", "16"); return 0; } //---------------------------------- // // filter init // //---------------------------------- if(ptr->tag & TC_FILTER_INIT) { if((vob = tc_get_vob())==NULL) return(-1); // filter init ok. // set defaults strength[instance] = 0.25; /* Blending factor. Do not exceed 2 ever */ cdiff[instance] = 6; /* Max difference in UV values */ ldiff[instance] = 8; /* Max difference in Y value */ range[instance] = 4; /* Search range */ if (options != NULL) { if(verbose) tc_log_info(MOD_NAME, "options=%s", options); optstr_get (options, "strength", "%f", &strength[instance]); optstr_get (options, "cdiff", "%d", &cdiff[instance]); optstr_get (options, "ldiff", "%d", &ldiff[instance]); optstr_get (options, "range", "%d", &range[instance]); } tbuf[instance] = tc_malloc(SIZE_RGB_FRAME); if (strength[instance]> 0.9) strength[instance] = 0.9; memset(tbuf[instance], 0, SIZE_RGB_FRAME); if (vob->im_v_codec == TC_CODEC_RGB24) { if (verbose) tc_log_error(MOD_NAME, "only capable of YUV mode"); return -1; } if(verbose) tc_log_info(MOD_NAME, "%s %s #%d", MOD_VERSION, MOD_CAP, ptr->filter_id); return(0); } //---------------------------------- // // filter close // //---------------------------------- if(ptr->tag & TC_FILTER_CLOSE) { if (tbuf[instance]) free(tbuf[instance]); tbuf[instance] = NULL; return(0); } //---------------------------------- // // filter frame routine // //---------------------------------- // tag variable indicates, if we are called before // transcodes internal video/audo frame processing routines // or after and determines video/audio context if(ptr->tag & TC_PRE_M_PROCESS && ptr->tag & TC_VIDEO && !(ptr->attributes & TC_FRAME_IS_SKIPPED)) { if (vob->im_v_codec == TC_CODEC_YUV420P) smooth_yuv(ptr->video_buf, ptr->v_width, ptr->v_height, cdiff[instance], ldiff[instance], range[instance], strength[instance], instance); } return(0); }