/** * Reads the value of a key associated with the sarray. * Returns true on success, false on failure. */ bool get_metadata(std::string key, std::string &val) const { ASSERT_NE(reader, NULL); if (reader == NULL) log_and_throw(std::string("Invalid sarray")); bool ret = false; std::tie(ret, val) = get_metadata(key); return ret; }
static int parse_dsd_diin(AVFormatContext *s, AVStream *st, uint64_t eof) { AVIOContext *pb = s->pb; while (avio_tell(pb) + 12 <= eof) { uint32_t tag = avio_rl32(pb); uint64_t size = avio_rb64(pb); uint64_t orig_pos = avio_tell(pb); const char * metadata_tag = NULL; switch(tag) { case MKTAG('D','I','A','R'): metadata_tag = "artist"; break; case MKTAG('D','I','T','I'): metadata_tag = "title"; break; } if (metadata_tag && size > 4) { unsigned int tag_size = avio_rb32(pb); int ret = get_metadata(s, metadata_tag, FFMIN(tag_size, size - 4)); if (ret < 0) { av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", metadata_tag); return ret; } } avio_skip(pb, size - (avio_tell(pb) - orig_pos) + (size & 1)); } return 0; }
void cb_update_metadata(void *handle) { dpl_async_task_t *atask = (dpl_async_task_t *) handle; dpl_async_task_free(atask); get_metadata(); }
static void cache_add_cache(struct peer_cache *dst, const struct peer_cache *add) { int i, meta_size; const uint8_t *meta; meta = get_metadata(add, &meta_size); for (i = 0; nodeid(add, i); i++) { cache_add(dst, nodeid(add, i), meta + (meta_size * i), meta_size); } }
int main() { int ret = 0; ret = get_metadata("/"); if (ret != 0) { printf("Failed\n"); return ret; } printf("Suceeded\n"); return 0; }
static void single_thread_get_metadata (GAsyncQueue *queue) { while (TRUE) { TrackerExtractTask *task; task = g_async_queue_pop (queue); g_message ("Dispatching '%s' in dedicated thread", task->file); get_metadata (task); } }
static track_t *track_create(const char *path, AVFormatContext *avctx, int track_index) { track_t *track; char *tmp; /*av_dump_format(avctx, 0, NULL, 0);*/ /* For each metadata first try container-level metadata. If no value is * found, try stream-specific metadata. */ track = track_new(); track->file = strcopy(path); track->title = copy_metadata(avctx, "title") ? : copy_metadata(avctx, "song"); if (!track->title) { /* No title in metadata, use plain filename (no basename, it's crap). */ for (tmp = (char *)path + strlen(path); tmp > path && *(tmp - 1) != '/'; --tmp) { } track->title = strcopy(tmp); } track->trackindex = track_index; tmp = get_metadata(avctx, "track"); if (tmp) { sscanf(tmp, "%d", &track->track); } else { track->track = track_index; } track->artist = copy_metadata(avctx, "artist") ? : copy_metadata(avctx, "author"); track->album = copy_metadata(avctx, "album") ? : copy_metadata(avctx, "game"); track->albumartist = copy_metadata(avctx, "albumartist"); if (avctx->duration > 0) { track->duration = avctx->duration / (double)AV_TIME_BASE; } else { track->duration = avctx->streams[0]->duration * av_q2d(avctx->streams[0]->time_base); } if (track->duration <= 0) { track_free(track); track = NULL; } return track; }
void DjVuANT::decode(class GLParser & parser) { bg_color=get_bg_color(parser); zoom=get_zoom(parser); mode=get_mode(parser); hor_align=get_hor_align(parser); ver_align=get_ver_align(parser); map_areas=get_map_areas(parser); #ifndef NO_METADATA_IN_ANT_CHUNK metadata=get_metadata(parser); #endif }
static void single_thread_get_metadata (GAsyncQueue *queue) { while (TRUE) { TrackerExtractTask *task; task = g_async_queue_pop (queue); #ifdef THREAD_ENABLE_TRACE g_debug ("Thread:%p --> '%s': Dispatching in dedicated thread", g_thread_self(), task->file); #endif /* THREAD_ENABLE_TRACE */ get_metadata (task); } }
static int update_metadata(int start_addr, struct tobj* tobj) { int metadata_l = 0; int metasize = 0; int i; int* metadata = NULL; struct tobj *t = tobj; struct meta *meta= &t->meta; //printf("update metadata %d \n", start_addr); metadata_l = get_metadata_l(t->fileindex, start_addr); if(is_meta_flag(t)){ free(meta->doc_list); } metadata = (int *)malloc(metadata_l * sizeof(int)); if(metadata == NULL) return 1; set_meta_flag(t); metasize = get_metasize(); //printf("metasize %d \n", metasize); t->chunk_off = metasize + 8; metadata_l = metadata_l >> 2; meta->doc_list = metadata; meta->doc_off = (metadata + metadata_l); meta->bv_off = (metadata + metadata_l * 2); meta->chunk_addr = (metadata + metadata_l * 3); metadata = get_metadata(); for(i = 0; i < metadata_l; i++){ meta->doc_list[i] = metadata[(i << 2)]; meta->doc_off[i] = metadata[(i << 2) + 1]; meta->bv_off[i] = metadata[(i << 2) + 2]; meta->chunk_addr[i] = metadata[(i << 2) + 3]; //printf("%d, %d, %d, %x \n", meta->doc_list[i], meta->doc_off[i], meta->bv_off[i], meta->chunk_addr[i]); } if(t->cur_block + 1 < t->block_num){ t->cur_chunk_e = metadata_l; }else{ t->cur_chunk_e = t->chunk_e + 1; if(t->cur_chunk_e > metadata_l) t->cur_chunk_e = metadata_l; } return 0; }
static void fill_combobox(const QString& filter, QList<DynamicLibrary*>& list, QComboBox* cbx, QComboBox* cbx2) { QDir settingsDir( QCoreApplication::applicationDirPath() ); QStringList filenames = settingsDir.entryList( QStringList() << (LIB_PREFIX + filter + SONAME), QDir::Files, QDir::Name ); for ( int i = 0; i < filenames.size(); i++) { QIcon icon; QString longName; QString str = filenames.at(i); DynamicLibrary* lib = new DynamicLibrary(str); qDebug() << "Loading" << str; std::cout.flush(); if (!get_metadata(lib, longName, icon)) { delete lib; continue; } list.push_back(lib); cbx->addItem(icon, longName); if (cbx2) cbx2->addItem(icon, longName); } }
int main(int argc, char **argv) { int ret; int session_id; plan_tests(NUM_TESTS); diag("Live unit tests"); ret = connect_viewer("localhost"); ok(ret == 0, "Connect viewer to relayd"); ret = establish_connection(); ok(ret == 0, "Established connection and version check with %d.%d", VERSION_MAJOR, VERSION_MINOR); ret = list_sessions(&session_id); ok(ret > 0, "List sessions : %d session(s)", ret); ret = attach_session(session_id); ok(ret > 0, "Attach to session, %d streams received", ret); ret = get_metadata(); ok(ret > 0, "Get metadata, received %d bytes", ret); ret = get_next_index(); ok(ret == 0, "Get one index per stream"); ret = get_data_packet(first_packet_stream_id, first_packet_offset, first_packet_len); ok(ret == first_packet_len, "Get one data packet for stream %d, offset %d, len %d", first_packet_stream_id, first_packet_offset, first_packet_len); return exit_status(); }
void ciObjectFactory::init_shared_objects() { _next_ident = 1; // start numbering CI objects at 1 { // Create the shared symbols, but not in _shared_ci_metadata. int i; for (i = vmSymbols::FIRST_SID; i < vmSymbols::SID_LIMIT; i++) { Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i); assert(vmSymbols::find_sid(vmsym) == i, "1-1 mapping"); ciSymbol* sym = new (_arena) ciSymbol(vmsym, (vmSymbols::SID) i); init_ident_of(sym); _shared_ci_symbols[i] = sym; } #ifdef ASSERT for (i = vmSymbols::FIRST_SID; i < vmSymbols::SID_LIMIT; i++) { Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i); ciSymbol* sym = vm_symbol_at((vmSymbols::SID) i); assert(sym->get_symbol() == vmsym, "oop must match"); } assert(ciSymbol::void_class_signature()->get_symbol() == vmSymbols::void_class_signature(), "spot check"); #endif } _ci_metadata = new (_arena) GrowableArray<ciMetadata*>(_arena, 64, 0, NULL); for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) { BasicType t = (BasicType)i; if (type2name(t) != NULL && t != T_OBJECT && t != T_ARRAY && t != T_NARROWOOP && t != T_NARROWKLASS) { ciType::_basic_types[t] = new (_arena) ciType(t); init_ident_of(ciType::_basic_types[t]); } } ciEnv::_null_object_instance = new (_arena) ciNullObject(); init_ident_of(ciEnv::_null_object_instance); #define WK_KLASS_DEFN(name, ignore_s, opt) \ if (SystemDictionary::name() != NULL) \ ciEnv::_##name = get_metadata(SystemDictionary::name())->as_instance_klass(); WK_KLASSES_DO(WK_KLASS_DEFN) #undef WK_KLASS_DEFN for (int len = -1; len != _ci_metadata->length(); ) { len = _ci_metadata->length(); for (int i2 = 0; i2 < len; i2++) { ciMetadata* obj = _ci_metadata->at(i2); assert (obj->is_metadata(), "what else would it be?"); if (obj->is_loaded() && obj->is_instance_klass()) { obj->as_instance_klass()->compute_nonstatic_fields(); } } } ciEnv::_unloaded_cisymbol = ciObjectFactory::get_symbol(vmSymbols::dummy_symbol()); // Create dummy InstanceKlass and ObjArrayKlass object and assign them idents ciEnv::_unloaded_ciinstance_klass = new (_arena) ciInstanceKlass(ciEnv::_unloaded_cisymbol, NULL, NULL); init_ident_of(ciEnv::_unloaded_ciinstance_klass); ciEnv::_unloaded_ciobjarrayklass = new (_arena) ciObjArrayKlass(ciEnv::_unloaded_cisymbol, ciEnv::_unloaded_ciinstance_klass, 1); init_ident_of(ciEnv::_unloaded_ciobjarrayklass); assert(ciEnv::_unloaded_ciobjarrayklass->is_obj_array_klass(), "just checking"); get_metadata(Universe::boolArrayKlassObj()); get_metadata(Universe::charArrayKlassObj()); get_metadata(Universe::singleArrayKlassObj()); get_metadata(Universe::doubleArrayKlassObj()); get_metadata(Universe::byteArrayKlassObj()); get_metadata(Universe::shortArrayKlassObj()); get_metadata(Universe::intArrayKlassObj()); get_metadata(Universe::longArrayKlassObj()); assert(_non_perm_count == 0, "no shared non-perm objects"); // The shared_ident_limit is the first ident number that will // be used for non-shared objects. That is, numbers less than // this limit are permanently assigned to shared CI objects, // while the higher numbers are recycled afresh by each new ciEnv. _shared_ident_limit = _next_ident; _shared_ci_metadata = _ci_metadata; }
static size_t wrap_send(uhd::tx_streamer *tx_stream, bp::object &np_array, bp::object &metadata, const double timeout = 0.1) { // Extract the metadata bp::extract<uhd::tx_metadata_t&> get_metadata(metadata); // TODO: throw an error here? if (not get_metadata.check()) { return 0; } // Get a numpy array object from given python object // No sanity checking possible! // Note: this increases the ref count, which we'll need to manually decrease at the end PyObject* array_obj = PyArray_FROM_OF(np_array.ptr(),NPY_ARRAY_CARRAY); PyArrayObject* array_type_obj = reinterpret_cast<PyArrayObject*>(array_obj); // Get dimensions of the numpy array const size_t dims = PyArray_NDIM(array_type_obj); const npy_intp* shape = PyArray_SHAPE(array_type_obj); // How many bytes to jump to get to the next element of the stride // (next row) const npy_intp* strides = PyArray_STRIDES(array_type_obj); const size_t channels = tx_stream->get_num_channels(); // Check if numpy array sizes are ok if (((channels > 1) && (dims != 2)) or ((size_t) shape[0] < channels)) { // Manually decrement the ref count Py_DECREF(array_obj); // If we don't have a 2D NumPy array, assume we have a 1D array size_t input_channels = (dims != 2) ? 1 : shape[0]; throw uhd::runtime_error(str(boost::format( "Number of TX channels (%d) does not match the dimensions of the data array (%d)") % channels % input_channels)); } // Get a pointer to the storage std::vector<void*> channel_storage; char* data = PyArray_BYTES(array_type_obj); for (size_t i = 0; i < channels; ++i) { channel_storage.push_back((void*)(data + i * strides[0])); } // Get data buffer and size of the array size_t nsamps_per_buff = (dims > 1) ? (size_t) shape[1] : PyArray_SIZE(array_type_obj); // Release the GIL only for the send() call const size_t result = [&]() { scoped_gil_release gil_release; // Call the real send() return tx_stream->send( channel_storage, nsamps_per_buff, get_metadata(), timeout ); }(); // Manually decrement the ref count Py_DECREF(array_obj); return result; }
static void decode_file(const char *input_fn) { /* Initialize DSP before any sort of interaction */ dsp_init(); /* Set up global settings */ memset(&global_settings, 0, sizeof(global_settings)); global_settings.timestretch_enabled = true; dsp_timestretch_enable(true); /* Open file */ if (!strcmp(input_fn, "-")) { input_fd = STDIN_FILENO; } else { input_fd = open(input_fn, O_RDONLY); if (input_fd == -1) { perror(input_fn); exit(1); } } /* Set up ci */ struct mp3entry id3; if (!get_metadata(&id3, input_fd, input_fn)) { fprintf(stderr, "error: metadata parsing failed\n"); exit(1); } print_mp3entry(&id3, stderr); ci.filesize = filesize(input_fd); ci.id3 = &id3; if (use_dsp) { ci.dsp = dsp_get_config(CODEC_IDX_AUDIO); dsp_configure(ci.dsp, DSP_SET_OUT_FREQUENCY, DSP_OUT_DEFAULT_HZ); dsp_configure(ci.dsp, DSP_RESET, 0); dsp_dither_enable(false); } perform_config(); /* Load codec */ char str[MAX_PATH]; snprintf(str, sizeof(str), CODECDIR"/%s.codec", audio_formats[id3.codectype].codec_root_fn); debugf("Loading %s\n", str); void *dlcodec = dlopen(str, RTLD_NOW); if (!dlcodec) { fprintf(stderr, "error: dlopen failed: %s\n", dlerror()); exit(1); } struct codec_header *c_hdr = NULL; c_hdr = dlsym(dlcodec, "__header"); if (c_hdr->lc_hdr.magic != CODEC_MAGIC) { fprintf(stderr, "error: %s invalid: incorrect magic\n", str); exit(1); } if (c_hdr->lc_hdr.target_id != TARGET_ID) { fprintf(stderr, "error: %s invalid: incorrect target id\n", str); exit(1); } if (c_hdr->lc_hdr.api_version != CODEC_API_VERSION) { fprintf(stderr, "error: %s invalid: incorrect API version\n", str); exit(1); } /* Run the codec */ *c_hdr->api = &ci; if (c_hdr->entry_point(CODEC_LOAD) != CODEC_OK) { fprintf(stderr, "error: codec returned error from codec_main\n"); exit(1); } if (c_hdr->run_proc() != CODEC_OK) { fprintf(stderr, "error: codec error\n"); } c_hdr->entry_point(CODEC_UNLOAD); /* Close */ dlclose(dlcodec); if (input_fd != STDIN_FILENO) close(input_fd); }
int MediaMetadataRetriever::getMetadata(bool update_only, bool apply_filter, AVDictionary **metadata) { return get_metadata(&state, metadata); }
ciMethodData* get_method_data(MethodData* o) { if (o == NULL) return NULL; return get_metadata(o)->as_method_data(); }
ciKlass* get_klass(Klass* o) { if (o == NULL) return NULL; return get_metadata(o)->as_klass(); }
static char *copy_metadata(AVFormatContext *avctx, const char *key) { char *result = get_metadata(avctx, key); return strcopy(result); }
// ------------------------------------------------------------------ // ciEnv::get_method_from_handle ciMethod* ciEnv::get_method_from_handle(Method* method) { VM_ENTRY_MARK; return get_metadata(method)->as_method(); }
ciMethod* get_method(Method* o) { if (o == NULL) return NULL; return get_metadata(o)->as_method(); }
int main(int argc, char *argv[]) { char sig[37]; MetaData m; struct stat s; int index = 1; bool hasmeta = false; if (argc < 2) { printf("Usage: sigapp [-q] [-n] <mp3 file>\n"); printf(" -q => quiet mode\n"); printf(" -l => don't lookup data at musicbrainz\n"); exit(0); } if (strcmp(argv[index], "-q") == 0) { quiet = 1; index++; } if (strcmp(argv[index], "-l") == 0) { nosubmit = 1; index++; } if (get_metadata(argv[index], &m)) { stat(argv[index], &s); m.SetSize(s.st_size); if (!quiet) { printf("Local metadata:\n"); printf(" Title: %s\n", m.Title().c_str()); printf(" Album: %s\n", m.Album().c_str()); printf(" Artist: %s\n", m.Artist().c_str()); printf(" Genre: %s\n", m.Genre().c_str()); printf(" Comment: %s\n", m.Comment().c_str()); printf(" Track: %d\n", m.Track()); printf(" Time: %d\n", m.Time()); printf(" Size: %d\n", m.Size()); } hasmeta = true; } if (ff_decode(argv[index], sig, 0, 0, 0, 24000, 0)) { m.SetGUID(sig); if (!quiet) printf("Signature: "); printf("%s\n", sig); if (!nosubmit) { lookup_metadata(&m); } #ifdef SIG_DEBUG FILE *logfile = fopen("guid_mapping.txt", "a+"); fprintf(logfile,"%s\t%s\n", argv[index], sig); fclose(logfile); #endif } else { if (!quiet) printf("Error calculating signature.\n"); } return 0; }
static int iff_read_header(AVFormatContext *s) { IffDemuxContext *iff = s->priv_data; AVIOContext *pb = s->pb; AVStream *st; uint32_t chunk_id, data_size; int compression = -1; st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); st->codecpar->channels = 1; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO; avio_skip(pb, 8); // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content st->codecpar->codec_tag = avio_rl32(pb); while(!pb->eof_reached) { uint64_t orig_pos; int res; const char *metadata_tag = NULL; chunk_id = avio_rl32(pb); data_size = avio_rb32(pb); orig_pos = avio_tell(pb); switch(chunk_id) { case ID_VHDR: st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; if (data_size < 14) return AVERROR_INVALIDDATA; avio_skip(pb, 12); st->codecpar->sample_rate = avio_rb16(pb); if (data_size >= 16) { avio_skip(pb, 1); compression = avio_r8(pb); } break; case ID_BODY: iff->body_pos = avio_tell(pb); iff->body_size = data_size; break; case ID_CHAN: if (data_size < 4) return AVERROR_INVALIDDATA; if (avio_rb32(pb) < 6) { st->codecpar->channels = 1; st->codecpar->channel_layout = AV_CH_LAYOUT_MONO; } else { st->codecpar->channels = 2; st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO; } break; case ID_CMAP: if (data_size < 3 || data_size > 768 || data_size % 3) { av_log(s, AV_LOG_ERROR, "Invalid CMAP chunk size %"PRIu32"\n", data_size); return AVERROR_INVALIDDATA; } st->codecpar->extradata_size = data_size; st->codecpar->extradata = av_malloc(data_size); if (!st->codecpar->extradata) return AVERROR(ENOMEM); if (avio_read(pb, st->codecpar->extradata, data_size) < 0) return AVERROR(EIO); break; case ID_BMHD: st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; if (data_size <= 8) return AVERROR_INVALIDDATA; st->codecpar->width = avio_rb16(pb); st->codecpar->height = avio_rb16(pb); avio_skip(pb, 4); // x, y offset st->codecpar->bits_per_coded_sample = avio_r8(pb); if (data_size >= 11) { avio_skip(pb, 1); // masking compression = avio_r8(pb); } if (data_size >= 16) { avio_skip(pb, 3); // paddding, transparent st->sample_aspect_ratio.num = avio_r8(pb); st->sample_aspect_ratio.den = avio_r8(pb); } break; case ID_ANNO: case ID_TEXT: metadata_tag = "comment"; break; case ID_AUTH: metadata_tag = "artist"; break; case ID_COPYRIGHT: metadata_tag = "copyright"; break; case ID_NAME: metadata_tag = "title"; break; } if (metadata_tag) { if ((res = get_metadata(s, metadata_tag, data_size)) < 0) { av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!", metadata_tag); return res; } } avio_skip(pb, data_size - (avio_tell(pb) - orig_pos) + (data_size & 1)); } avio_seek(pb, iff->body_pos, SEEK_SET); switch(st->codecpar->codec_type) { case AVMEDIA_TYPE_AUDIO: avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate); switch(compression) { case COMP_NONE: st->codecpar->codec_id = AV_CODEC_ID_PCM_S8_PLANAR; break; case COMP_FIB: st->codecpar->codec_id = AV_CODEC_ID_8SVX_FIB; break; case COMP_EXP: st->codecpar->codec_id = AV_CODEC_ID_8SVX_EXP; break; default: av_log(s, AV_LOG_ERROR, "unknown compression method\n"); return -1; } st->codecpar->bits_per_coded_sample = 8; st->codecpar->bit_rate = st->codecpar->channels * st->codecpar->sample_rate * st->codecpar->bits_per_coded_sample; st->codecpar->block_align = st->codecpar->channels * st->codecpar->bits_per_coded_sample; break; case AVMEDIA_TYPE_VIDEO: switch (compression) { case BITMAP_RAW: st->codecpar->codec_id = AV_CODEC_ID_IFF_ILBM; break; case BITMAP_BYTERUN1: st->codecpar->codec_id = AV_CODEC_ID_IFF_BYTERUN1; break; default: av_log(s, AV_LOG_ERROR, "unknown compression method\n"); return AVERROR_INVALIDDATA; } break; default: return -1; } return 0; }
static const void *cyclon_get_metadata(struct peersampler_context *context, int *metadata_size) { return get_metadata(context->local_cache, metadata_size); }
static int iff_read_header(AVFormatContext *s) { IffDemuxContext *iff = s->priv_data; AVIOContext *pb = s->pb; AVStream *st; uint8_t *buf; uint32_t chunk_id, data_size; uint32_t screenmode = 0, num, den; unsigned transparency = 0; unsigned masking = 0; // no mask uint8_t fmt[16]; int fmt_size; st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); st->codec->channels = 1; st->codec->channel_layout = AV_CH_LAYOUT_MONO; avio_skip(pb, 8); // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content st->codec->codec_tag = avio_rl32(pb); iff->bitmap_compression = -1; iff->svx8_compression = -1; iff->maud_bits = -1; iff->maud_compression = -1; while(!url_feof(pb)) { uint64_t orig_pos; int res; const char *metadata_tag = NULL; chunk_id = avio_rl32(pb); data_size = avio_rb32(pb); orig_pos = avio_tell(pb); switch(chunk_id) { case ID_VHDR: st->codec->codec_type = AVMEDIA_TYPE_AUDIO; if (data_size < 14) return AVERROR_INVALIDDATA; avio_skip(pb, 12); st->codec->sample_rate = avio_rb16(pb); if (data_size >= 16) { avio_skip(pb, 1); iff->svx8_compression = avio_r8(pb); } break; case ID_MHDR: st->codec->codec_type = AVMEDIA_TYPE_AUDIO; if (data_size < 32) return AVERROR_INVALIDDATA; avio_skip(pb, 4); iff->maud_bits = avio_rb16(pb); avio_skip(pb, 2); num = avio_rb32(pb); den = avio_rb16(pb); if (!den) return AVERROR_INVALIDDATA; avio_skip(pb, 2); st->codec->sample_rate = num / den; st->codec->channels = avio_rb16(pb); iff->maud_compression = avio_rb16(pb); if (st->codec->channels == 1) st->codec->channel_layout = AV_CH_LAYOUT_MONO; else if (st->codec->channels == 2) st->codec->channel_layout = AV_CH_LAYOUT_STEREO; break; case ID_ABIT: case ID_BODY: case ID_DBOD: case ID_MDAT: iff->body_pos = avio_tell(pb); iff->body_end = iff->body_pos + data_size; iff->body_size = data_size; break; case ID_CHAN: if (data_size < 4) return AVERROR_INVALIDDATA; if (avio_rb32(pb) < 6) { st->codec->channels = 1; st->codec->channel_layout = AV_CH_LAYOUT_MONO; } else { st->codec->channels = 2; st->codec->channel_layout = AV_CH_LAYOUT_STEREO; } break; case ID_CAMG: if (data_size < 4) return AVERROR_INVALIDDATA; screenmode = avio_rb32(pb); break; case ID_CMAP: if (data_size < 3 || data_size > 768 || data_size % 3) { av_log(s, AV_LOG_ERROR, "Invalid CMAP chunk size %"PRIu32"\n", data_size); return AVERROR_INVALIDDATA; } st->codec->extradata_size = data_size + IFF_EXTRA_VIDEO_SIZE; st->codec->extradata = av_malloc(data_size + IFF_EXTRA_VIDEO_SIZE + FF_INPUT_BUFFER_PADDING_SIZE); if (!st->codec->extradata) return AVERROR(ENOMEM); if (avio_read(pb, st->codec->extradata + IFF_EXTRA_VIDEO_SIZE, data_size) < 0) return AVERROR(EIO); break; case ID_BMHD: st->codec->codec_type = AVMEDIA_TYPE_VIDEO; if (data_size <= 8) return AVERROR_INVALIDDATA; st->codec->width = avio_rb16(pb); st->codec->height = avio_rb16(pb); avio_skip(pb, 4); // x, y offset st->codec->bits_per_coded_sample = avio_r8(pb); if (data_size >= 10) masking = avio_r8(pb); if (data_size >= 11) iff->bitmap_compression = avio_r8(pb); if (data_size >= 14) { avio_skip(pb, 1); // padding transparency = avio_rb16(pb); } if (data_size >= 16) { st->sample_aspect_ratio.num = avio_r8(pb); st->sample_aspect_ratio.den = avio_r8(pb); } break; case ID_DPEL: if (data_size < 4 || (data_size & 3)) return AVERROR_INVALIDDATA; if ((fmt_size = avio_read(pb, fmt, sizeof(fmt))) < 0) return fmt_size; if (fmt_size == sizeof(deep_rgb24) && !memcmp(fmt, deep_rgb24, sizeof(deep_rgb24))) st->codec->pix_fmt = AV_PIX_FMT_RGB24; else if (fmt_size == sizeof(deep_rgba) && !memcmp(fmt, deep_rgba, sizeof(deep_rgba))) st->codec->pix_fmt = AV_PIX_FMT_RGBA; else if (fmt_size == sizeof(deep_bgra) && !memcmp(fmt, deep_bgra, sizeof(deep_bgra))) st->codec->pix_fmt = AV_PIX_FMT_BGRA; else if (fmt_size == sizeof(deep_argb) && !memcmp(fmt, deep_argb, sizeof(deep_argb))) st->codec->pix_fmt = AV_PIX_FMT_ARGB; else if (fmt_size == sizeof(deep_abgr) && !memcmp(fmt, deep_abgr, sizeof(deep_abgr))) st->codec->pix_fmt = AV_PIX_FMT_ABGR; else { avpriv_request_sample(s, "color format %.16s", fmt); return AVERROR_PATCHWELCOME; } break; case ID_DGBL: st->codec->codec_type = AVMEDIA_TYPE_VIDEO; if (data_size < 8) return AVERROR_INVALIDDATA; st->codec->width = avio_rb16(pb); st->codec->height = avio_rb16(pb); iff->bitmap_compression = avio_rb16(pb); st->sample_aspect_ratio.num = avio_r8(pb); st->sample_aspect_ratio.den = avio_r8(pb); st->codec->bits_per_coded_sample = 24; break; case ID_DLOC: if (data_size < 4) return AVERROR_INVALIDDATA; st->codec->width = avio_rb16(pb); st->codec->height = avio_rb16(pb); break; case ID_TVDC: if (data_size < sizeof(iff->tvdc)) return AVERROR_INVALIDDATA; res = avio_read(pb, iff->tvdc, sizeof(iff->tvdc)); if (res < 0) return res; break; case ID_ANNO: case ID_TEXT: metadata_tag = "comment"; break; case ID_AUTH: metadata_tag = "artist"; break; case ID_COPYRIGHT: metadata_tag = "copyright"; break; case ID_NAME: metadata_tag = "title"; break; } if (metadata_tag) { if ((res = get_metadata(s, metadata_tag, data_size)) < 0) { av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!\n", metadata_tag); return res; } } avio_skip(pb, data_size - (avio_tell(pb) - orig_pos) + (data_size & 1)); } avio_seek(pb, iff->body_pos, SEEK_SET); switch(st->codec->codec_type) { case AVMEDIA_TYPE_AUDIO: avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate); if (st->codec->codec_tag == ID_16SV) st->codec->codec_id = AV_CODEC_ID_PCM_S16BE_PLANAR; else if (st->codec->codec_tag == ID_MAUD) { if (iff->maud_bits == 8 && !iff->maud_compression) { st->codec->codec_id = AV_CODEC_ID_PCM_U8; } else if (iff->maud_bits == 16 && !iff->maud_compression) { st->codec->codec_id = AV_CODEC_ID_PCM_S16BE; } else if (iff->maud_bits == 8 && iff->maud_compression == 2) { st->codec->codec_id = AV_CODEC_ID_PCM_ALAW; } else if (iff->maud_bits == 8 && iff->maud_compression == 3) { st->codec->codec_id = AV_CODEC_ID_PCM_MULAW; } else { avpriv_request_sample(s, "compression %d and bit depth %d", iff->maud_compression, iff->maud_bits); return AVERROR_PATCHWELCOME; } } else { switch (iff->svx8_compression) { case COMP_NONE: st->codec->codec_id = AV_CODEC_ID_PCM_S8_PLANAR; break; case COMP_FIB: st->codec->codec_id = AV_CODEC_ID_8SVX_FIB; break; case COMP_EXP: st->codec->codec_id = AV_CODEC_ID_8SVX_EXP; break; default: av_log(s, AV_LOG_ERROR, "Unknown SVX8 compression method '%d'\n", iff->svx8_compression); return -1; } } st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id); st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * st->codec->bits_per_coded_sample; st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample; break; case AVMEDIA_TYPE_VIDEO: iff->bpp = st->codec->bits_per_coded_sample; if ((screenmode & 0x800 /* Hold And Modify */) && iff->bpp <= 8) { iff->ham = iff->bpp > 6 ? 6 : 4; st->codec->bits_per_coded_sample = 24; } iff->flags = (screenmode & 0x80 /* Extra HalfBrite */) && iff->bpp <= 8; iff->masking = masking; iff->transparency = transparency; if (!st->codec->extradata) { st->codec->extradata_size = IFF_EXTRA_VIDEO_SIZE; st->codec->extradata = av_malloc(IFF_EXTRA_VIDEO_SIZE + FF_INPUT_BUFFER_PADDING_SIZE); if (!st->codec->extradata) return AVERROR(ENOMEM); } av_assert0(st->codec->extradata_size >= IFF_EXTRA_VIDEO_SIZE); buf = st->codec->extradata; bytestream_put_be16(&buf, IFF_EXTRA_VIDEO_SIZE); bytestream_put_byte(&buf, iff->bitmap_compression); bytestream_put_byte(&buf, iff->bpp); bytestream_put_byte(&buf, iff->ham); bytestream_put_byte(&buf, iff->flags); bytestream_put_be16(&buf, iff->transparency); bytestream_put_byte(&buf, iff->masking); bytestream_put_buffer(&buf, iff->tvdc, sizeof(iff->tvdc)); st->codec->codec_id = AV_CODEC_ID_IFF_ILBM; break; default: return -1; } return 0; }
/* This function is executed in the main thread, decides the * module that's going to be run for a given task, and dispatches * the task according to the threading strategy of that module. */ static gboolean dispatch_task_cb (TrackerExtractTask *task) { TrackerModuleThreadAwareness thread_awareness; TrackerExtractPrivate *priv; GError *error = NULL; GModule *module; #ifdef THREAD_ENABLE_TRACE g_debug ("Thread:%p (Main) <-- File:'%s' - Dispatching\n", g_thread_self (), task->file); #endif /* THREAD_ENABLE_TRACE */ priv = TRACKER_EXTRACT_GET_PRIVATE (task->extract); if (!task->mimetype) { error = g_error_new (TRACKER_DBUS_ERROR, 0, "No mimetype for '%s'", task->file); } else { if (!task->mimetype_handlers) { /* First iteration for task, get the mimetype handlers */ task->mimetype_handlers = tracker_extract_module_manager_get_mimetype_handlers (task->mimetype); if (!task->mimetype_handlers) { error = g_error_new (TRACKER_DBUS_ERROR, 0, "No mimetype extractor handlers for uri:'%s' and mime:'%s'", task->file, task->mimetype); } } else { /* Any further iteration, should happen rarely if * most specific handlers know nothing about the file */ g_message ("Trying next extractor for '%s'", task->file); if (!tracker_mimetype_info_iter_next (task->mimetype_handlers)) { g_message (" There's no next extractor"); error = g_error_new (TRACKER_DBUS_ERROR, 0, "Could not get any metadata for uri:'%s' and mime:'%s'", task->file, task->mimetype); } } } if (error) { g_simple_async_result_set_from_error ((GSimpleAsyncResult *) task->res, error); g_simple_async_result_complete_in_idle ((GSimpleAsyncResult *) task->res); extract_task_free (task); g_error_free (error); return FALSE; } task->cur_module = module = tracker_mimetype_info_get_module (task->mimetype_handlers, &task->cur_func, &thread_awareness); if (!module || !task->cur_func) { g_warning ("Discarding task with no module '%s'", task->file); priv->unhandled_count++; return FALSE; } g_mutex_lock (&priv->task_mutex); priv->running_tasks = g_list_prepend (priv->running_tasks, task); g_mutex_unlock (&priv->task_mutex); switch (thread_awareness) { case TRACKER_MODULE_NONE: /* Error out */ g_simple_async_result_set_error ((GSimpleAsyncResult *) task->res, TRACKER_DBUS_ERROR, 0, "Module '%s' initialization failed", g_module_name (module)); g_simple_async_result_complete_in_idle ((GSimpleAsyncResult *) task->res); extract_task_free (task); break; case TRACKER_MODULE_MAIN_THREAD: /* Dispatch the task right away in this thread */ g_message ("Dispatching '%s' in main thread", task->file); get_metadata (task); break; case TRACKER_MODULE_SINGLE_THREAD: { GAsyncQueue *async_queue; async_queue = g_hash_table_lookup (priv->single_thread_extractors, module); if (!async_queue) { GThread *thread; /* No thread created yet for this module, create it * together with the async queue used to pass data to it */ async_queue = g_async_queue_new (); thread = g_thread_try_new ("single", (GThreadFunc) single_thread_get_metadata, g_async_queue_ref (async_queue), &error); if (!thread) { g_simple_async_result_take_error ((GSimpleAsyncResult *) task->res, error); g_simple_async_result_complete_in_idle ((GSimpleAsyncResult *) task->res); extract_task_free (task); return FALSE; } /* We won't join the thread, so just unref it here */ g_object_unref (thread); g_hash_table_insert (priv->single_thread_extractors, module, async_queue); } g_async_queue_push (async_queue, task); break; } case TRACKER_MODULE_MULTI_THREAD: /* Put task in thread pool */ g_message ("Dispatching '%s' in thread pool", task->file); g_thread_pool_push (priv->thread_pool, task, &error); if (error) { g_simple_async_result_set_from_error ((GSimpleAsyncResult *) task->res, error); g_simple_async_result_complete_in_idle ((GSimpleAsyncResult *) task->res); extract_task_free (task); g_error_free (error); return FALSE; } break; } return FALSE; }
void edit_main_rep::print (url name, bool conform, int first, int last) { bool ps = (suffix (name) == "ps"); bool pdf = (suffix (name) == "pdf"); url orig= resolve (name, ""); #ifdef USE_GS if (!use_pdf () && pdf) name= url_temp (".ps"); if (!use_ps () && ps) name= url_temp (".pdf"); #endif string medium = env->get_string (PAGE_MEDIUM); if (conform && (medium != "paper")) conform= false; // FIXME: better command for conform printing // Set environment variables for printing typeset_prepare (); env->write (DPI, printing_dpi); env->write (PAGE_SHOW_HF, "true"); env->write (PAGE_SCREEN_MARGIN, "false"); if (!conform) { env->write (PAGE_MEDIUM, "paper"); env->write (PAGE_PRINTED, "true"); } // Typeset pages for printing box the_box= typeset_as_document (env, subtree (et, rp), reverse (rp)); // Determine parameters for printer string page_type = env->get_string (PAGE_TYPE); double w = env->page_width; double h = env->page_height; double cm = env->as_length (string ("1cm")); bool landsc = env->page_landscape; int dpi = as_int (printing_dpi); int start = max (0, first-1); int end = min (N(the_box[0]), last); int pages = end-start; if (conform) { page_type= "user"; SI bw= the_box[0][0]->w(); SI bh= the_box[0][0]->h(); string bws= as_string (bw) * "tmpt"; string bhs= as_string (bh) * "tmpt"; w= env->as_length (bws); h= env->as_length (bhs); } // Print pages renderer ren; #ifdef PDF_RENDERER if (use_pdf () && (pdf || !use_ps ())) ren= pdf_hummus_renderer (name, dpi, pages, page_type, landsc, w/cm, h/cm); else ren= printer (name, dpi, pages, page_type, landsc, w/cm, h/cm); #else ren= printer (name, dpi, pages, page_type, landsc, w/cm, h/cm); #endif if (ren->is_started ()) { int i; ren->set_metadata ("title", get_metadata ("title")); ren->set_metadata ("author", get_metadata ("author")); ren->set_metadata ("subject", get_metadata ("subject")); for (i=start; i<end; i++) { tree bg= env->read (BG_COLOR); ren->set_background (bg); if (bg != "white") ren->clear_pattern (0, (SI) -h, (SI) w, 0); rectangles rs; the_box[0]->sx(i)= 0; the_box[0]->sy(i)= 0; the_box[0][i]->redraw (ren, path (0), rs); if (i<end-1) ren->next_page (); } } tm_delete (ren); #ifdef USE_GS if (!use_pdf () && pdf) { gs_to_pdf (name, orig, landsc, h/cm, w/cm); ::remove (name); } if (!use_ps () && ps) { gs_to_ps (name, orig, landsc, h/cm, w/cm); ::remove (name); } if (ps || pdf) if (get_preference ("texmacs->pdf:check", "off") == "on") { system_wait ("Checking exported file for correctness", "please wait"); gs_check (orig); } #endif }
ciTypeArrayKlass* get_type_array_klass(Klass* o) { if (o == NULL) return NULL; return get_metadata(o)->as_type_array_klass(); }
static int iff_read_header(AVFormatContext *s) { IffDemuxContext *iff = s->priv_data; AVIOContext *pb = s->pb; AVStream *st; uint8_t *buf; uint32_t chunk_id, data_size; uint32_t screenmode = 0; unsigned transparency = 0; unsigned masking = 0; // no mask uint8_t fmt[16]; int fmt_size; st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); st->codec->channels = 1; avio_skip(pb, 8); // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content st->codec->codec_tag = avio_rl32(pb); while(!url_feof(pb)) { uint64_t orig_pos; int res; const char *metadata_tag = NULL; chunk_id = avio_rl32(pb); data_size = avio_rb32(pb); orig_pos = avio_tell(pb); switch(chunk_id) { case ID_VHDR: st->codec->codec_type = AVMEDIA_TYPE_AUDIO; if (data_size < 14) return AVERROR_INVALIDDATA; avio_skip(pb, 12); st->codec->sample_rate = avio_rb16(pb); if (data_size >= 16) { avio_skip(pb, 1); iff->svx8_compression = avio_r8(pb); } break; case ID_ABIT: case ID_BODY: case ID_DBOD: iff->body_pos = avio_tell(pb); iff->body_size = data_size; break; case ID_CHAN: if (data_size < 4) return AVERROR_INVALIDDATA; st->codec->channels = (avio_rb32(pb) < 6) ? 1 : 2; break; case ID_CAMG: if (data_size < 4) return AVERROR_INVALIDDATA; screenmode = avio_rb32(pb); break; case ID_CMAP: st->codec->extradata_size = data_size + IFF_EXTRA_VIDEO_SIZE; st->codec->extradata = av_malloc(data_size + IFF_EXTRA_VIDEO_SIZE + FF_INPUT_BUFFER_PADDING_SIZE); if (!st->codec->extradata) return AVERROR(ENOMEM); if (avio_read(pb, st->codec->extradata + IFF_EXTRA_VIDEO_SIZE, data_size) < 0) return AVERROR(EIO); break; case ID_BMHD: iff->bitmap_compression = -1; st->codec->codec_type = AVMEDIA_TYPE_VIDEO; if (data_size <= 8) return AVERROR_INVALIDDATA; st->codec->width = avio_rb16(pb); st->codec->height = avio_rb16(pb); avio_skip(pb, 4); // x, y offset st->codec->bits_per_coded_sample = avio_r8(pb); if (data_size >= 10) masking = avio_r8(pb); if (data_size >= 11) iff->bitmap_compression = avio_r8(pb); if (data_size >= 14) { avio_skip(pb, 1); // padding transparency = avio_rb16(pb); } if (data_size >= 16) { st->sample_aspect_ratio.num = avio_r8(pb); st->sample_aspect_ratio.den = avio_r8(pb); } break; case ID_DPEL: if (data_size < 4 || (data_size & 3)) return AVERROR_INVALIDDATA; if ((fmt_size = avio_read(pb, fmt, sizeof(fmt))) < 0) return fmt_size; if (fmt_size == sizeof(deep_rgb24) && !memcmp(fmt, deep_rgb24, sizeof(deep_rgb24))) st->codec->pix_fmt = PIX_FMT_RGB24; else if (fmt_size == sizeof(deep_rgba) && !memcmp(fmt, deep_rgba, sizeof(deep_rgba))) st->codec->pix_fmt = PIX_FMT_RGBA; else { av_log_ask_for_sample(s, "unsupported color format\n"); return AVERROR_PATCHWELCOME; } break; case ID_DGBL: st->codec->codec_type = AVMEDIA_TYPE_VIDEO; if (data_size < 8) return AVERROR_INVALIDDATA; st->codec->width = avio_rb16(pb); st->codec->height = avio_rb16(pb); iff->bitmap_compression = avio_rb16(pb); if (iff->bitmap_compression != 0) { av_log(s, AV_LOG_ERROR, "compression %i not supported\n", iff->bitmap_compression); return AVERROR_PATCHWELCOME; } st->sample_aspect_ratio.num = avio_r8(pb); st->sample_aspect_ratio.den = avio_r8(pb); st->codec->bits_per_coded_sample = 24; break; case ID_ANNO: case ID_TEXT: metadata_tag = "comment"; break; case ID_AUTH: metadata_tag = "artist"; break; case ID_COPYRIGHT: metadata_tag = "copyright"; break; case ID_NAME: metadata_tag = "title"; break; } if (metadata_tag) { if ((res = get_metadata(s, metadata_tag, data_size)) < 0) { av_log(s, AV_LOG_ERROR, "cannot allocate metadata tag %s!", metadata_tag); return res; } } avio_skip(pb, data_size - (avio_tell(pb) - orig_pos) + (data_size & 1)); } avio_seek(pb, iff->body_pos, SEEK_SET); switch(st->codec->codec_type) { case AVMEDIA_TYPE_AUDIO: avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate); switch (iff->svx8_compression) { case COMP_NONE: st->codec->codec_id = AV_CODEC_ID_PCM_S8_PLANAR; break; case COMP_FIB: st->codec->codec_id = AV_CODEC_ID_8SVX_FIB; break; case COMP_EXP: st->codec->codec_id = AV_CODEC_ID_8SVX_EXP; break; default: av_log(s, AV_LOG_ERROR, "Unknown SVX8 compression method '%d'\n", iff->svx8_compression); return -1; } st->codec->bits_per_coded_sample = iff->svx8_compression == COMP_NONE ? 8 : 4; st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * st->codec->bits_per_coded_sample; st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample; break; case AVMEDIA_TYPE_VIDEO: iff->bpp = st->codec->bits_per_coded_sample; if ((screenmode & 0x800 /* Hold And Modify */) && iff->bpp <= 8) { iff->ham = iff->bpp > 6 ? 6 : 4; st->codec->bits_per_coded_sample = 24; } iff->flags = (screenmode & 0x80 /* Extra HalfBrite */) && iff->bpp <= 8; iff->masking = masking; iff->transparency = transparency; if (!st->codec->extradata) { st->codec->extradata_size = IFF_EXTRA_VIDEO_SIZE; st->codec->extradata = av_malloc(IFF_EXTRA_VIDEO_SIZE + FF_INPUT_BUFFER_PADDING_SIZE); if (!st->codec->extradata) return AVERROR(ENOMEM); } buf = st->codec->extradata; bytestream_put_be16(&buf, IFF_EXTRA_VIDEO_SIZE); bytestream_put_byte(&buf, iff->bitmap_compression); bytestream_put_byte(&buf, iff->bpp); bytestream_put_byte(&buf, iff->ham); bytestream_put_byte(&buf, iff->flags); bytestream_put_be16(&buf, iff->transparency); bytestream_put_byte(&buf, iff->masking); switch (iff->bitmap_compression) { case BITMAP_RAW: st->codec->codec_id = AV_CODEC_ID_IFF_ILBM; break; case BITMAP_BYTERUN1: st->codec->codec_id = AV_CODEC_ID_IFF_BYTERUN1; break; default: av_log(s, AV_LOG_ERROR, "Unknown bitmap compression method '%d'\n", iff->bitmap_compression); return AVERROR_INVALIDDATA; } break; default: return -1; } return 0; }
ciInstanceKlass* get_instance_klass(Klass* o) { if (o == NULL) return NULL; return get_metadata(o)->as_instance_klass(); }