Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
qemu | hw/hw.h | int pci_device_load(PCIDevice *s, QEMUFile *f)
{
uint8_t config[PCI_CONFIG_SPACE_SIZE];
uint32_t version_id;
int i;
version_id = qemu_get_be32(f);
if (version_id > 2)
return -EINVAL;
qemu_get_buffer(f, config, sizeof config);
for (i = 0; i < sizeof config; ++i)
if ((config[i] ^ s->config... | [
1,
0
] |
qemu | block/nbd.c | void qio_dns_resolver_lookup_result(QIODNSResolver *resolver,
QIOTask *task,
size_t *naddrs,
SocketAddress ***addrs)
{
struct QIODNSResolverLookupData *data =
qio_task_get_result_pointer(task);
s... | [
0,
0
] |
qemu | hw/ppc/spapr.c | void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev,
Error **errp)
{
int index;
sPAPRDRConnector *drc;
sPAPRDRConnectorClass *drck;
Error *local_err = NULL;
CPUCore *cc = CPU_CORE(dev);
int smt = kvmppc_smt_threads();
if (!spapr_find_cpu_slo... | [
0,
0
] |
qemu | gdbstub.c | static void gdb_accept(void *opaque)
{
GDBState *s;
struct sockaddr_in sockaddr;
socklen_t len;
int val, fd;
for (;;) {
len = sizeof(sockaddr);
fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
if (fd < 0 && errno != EINTR) {
perror("accept");
return;
} els... | [
1,
1
] |
FFmpeg | libavcodec/h264_loopfilter.c | static void av_always_inline filter_mb_mbaff_edgev(H264Context *h, uint8_t *pix,
int stride,
const int16_t bS[7], int bsi,
int qp, int intra) {
const int qp_bd_offs... | [
1,
0
] |
FFmpeg | libavutil/eval.c | double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
{
Parser p;
p.const_values = const_values;
p.opaque = opaque;
return eval_expr(&p, e);
} | [
0,
0
] |
qemu | hw/display/cirrus_vga.c | static void cirrus_bitblt_cputovideo_next(CirrusVGAState *s)
{
int copy_count;
uint8_t *end_ptr;
if (s->cirrus_srccounter > 0) {
if (s->cirrus_blt_mode & CIRRUS_BLTMODE_PATTERNCOPY) {
cirrus_bitblt_common_patterncopy(s, false);
the_end:
s->cirrus_srccounter = 0;
cirrus_bitblt_re... | [
1,
1
] |
qemu | hw/acpi/nvdimm.c | nvdimm_build_structure_memdev(GArray *structures, DeviceState *dev)
{
NvdimmNfitMemDev *nfit_memdev;
uint64_t addr = object_property_get_int(OBJECT(dev), PC_DIMM_ADDR_PROP,
NULL);
uint64_t size = object_property_get_int(OBJECT(dev), PC_DIMM_SIZE_PROP,
... | [
1,
0
] |
qemu | cpu-all.h | static void apic_reset(void *opaque)
{
APICState *s = opaque;
int bsp = cpu_is_bsp(s->cpu_env);
s->apicbase = 0xfee00000 |
(bsp ? MSR_IA32_APICBASE_BSP : 0) | MSR_IA32_APICBASE_ENABLE;
apic_init_ipi(s);
if (bsp) {
/*
* LINT0 delivery mode on CPU #0 is set to ExtInt at initial... | [
1,
0
] |
qemu | hw/acpi/aml-build.c | build_dmar_q35(GArray *table_data, GArray *linker)
{
int dmar_start = table_data->len;
AcpiTableDmar *dmar;
AcpiDmarHardwareUnit *drhd;
dmar = acpi_data_push(table_data, sizeof(*dmar));
dmar->host_address_width = VTD_HOST_ADDRESS_WIDTH - 1;
dmar->flags = 0; /* No intr_remap for now */
/* DMAR Rema... | [
1,
0
] |
qemu | hw/block/virtio-blk.c | int virtio_set_status(VirtIODevice *vdev, uint8_t val)
{
VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
trace_virtio_set_status(vdev, val);
if (virtio_has_feature(vdev, VIRTIO_F_VERSION_1)) {
if (!(vdev->status & VIRTIO_CONFIG_S_FEATURES_OK) &&
val & VIRTIO_CONFIG_S_FEATURES_OK) {
... | [
0,
0
] |
qemu | HACKING | static void mv88w8618_flashcfg_write(void *opaque, target_phys_addr_t offset,
uint64_t value, unsigned size)
{
mv88w8618_flashcfg_state *s = opaque;
switch (offset) {
case MP_FLASHCFG_CFGR0:
s->cfgr0 = value;
break;
}
} | [
1,
0
] |
FFmpeg | doc/filters.texi | static int config(struct vf_instance *vf,
int width, int height, int d_width, int d_height,
unsigned int flags, unsigned int outfmt)
{
/* FIXME - also support UYVY output? */
return ff_vf_next_config(vf, width * vf->priv->scalew,
height / vf->priv... | [
1,
1
] |
FFmpeg | libavcodec/dnxhddec.c | static int dnxhd_decode_row(AVCodecContext *avctx, void *data,
int rownb, int threadnb)
{
const DNXHDContext *ctx = avctx->priv_data;
uint32_t offset = ctx->mb_scan_index[rownb];
RowContext *row = ctx->rows + threadnb;
int x;
row->last_dc[0] =
row->last_dc[1] =
... | [
1,
0
] |
qemu | target-m68k/translate.c | static inline void gen_store(DisasContext *s, int opsize, TCGv addr, TCGv val)
{
int index = IS_USER(s);
s->is_mem = 1;
switch (opsize) {
case OS_BYTE:
tcg_gen_qemu_st8(val, addr, index);
break;
case OS_WORD:
tcg_gen_qemu_st16(val, addr, index);
break;
case OS_LONG:
case OS_SIN... | [
1,
0
] |
FFmpeg | libavcodec/pthread_slice.c | static av_always_inline void thread_park_workers(SliceThreadContext *c,
int thread_count)
{
while (c->current_job != thread_count + c->job_count)
pthread_cond_wait(&c->last_job_cond, &c->current_job_lock);
pthread_mutex_unlock(&c->current_job_lock);
} | [
1,
0
] |
qemu | hw/i386/acpi-build.c | bool qemu_log_in_addr_range(uint64_t addr)
{
if (debug_regions) {
int i = 0;
for (i = 0; i < debug_regions->len; i++) {
Range *range = &g_array_index(debug_regions, Range, i);
if (addr >= range->begin && addr <= range->end - 1) {
return true;
}
}
return false;
} el... | [
1,
0
] |
qemu | buffered_file.c | static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s)
{
int64_t rt = qemu_get_clock(rt_clock);
if (s->rtsr & (1 << 12))
s->last_swcr += (rt - s->last_sw) / 10;
s->last_sw = rt;
} | [
0,
0
] |
qemu | net/socket.c | static int net_socket_connect_init(NetClientState *peer,
const char *model,
const char *name,
const char *host_str)
{
socket_connect_data *c = g_new0(socket_connect_data, 1);
int fd = -1;
Error *local_e... | [
0,
0
] |
qemu | hw/s390x/css.c | int css_do_hsch(SubchDev *sch)
{
SCSW *s = &sch->curr_status.scsw;
PMCW *p = &sch->curr_status.pmcw;
int ret;
if (!(p->flags & (PMCW_FLAGS_MASK_DNV | PMCW_FLAGS_MASK_ENA))) {
ret = -ENODEV;
goto out;
}
if (((s->ctrl & SCSW_CTRL_MASK_STCTL) == SCSW_STCTL_STATUS_PEND) ||
(s->ctrl & (SCS... | [
0,
0
] |
qemu | hw/xilinx_spips.c | static void xilinx_spips_flush_txfifo(XilinxSPIPS *s)
{
for (;;) {
int i;
uint8_t rx;
uint8_t tx = 0;
for (i = 0; i < num_effective_busses(s); ++i) {
if (!i || s->snoop_state == SNOOP_STRIPING) {
if (fifo8_is_empty(&s->tx_fifo)) {
s->regs[R_INTR_STATUS] |= IXR_TX_FIFO_... | [
1,
1
] |
qemu | target-arm/helper.h | static void gen_exception_return(DisasContext *s, TCGv_i32 pc)
{
TCGv_i32 tmp;
store_reg(s, 15, pc);
tmp = load_cpu_field(spsr);
gen_set_cpsr(tmp, CPSR_ERET_MASK);
tcg_temp_free_i32(tmp);
s->is_jmp = DISAS_JUMP;
} | [
0,
0
] |
qemu | include/qom/object.h | void object_property_add_link(Object *obj, const char *name,
const char *type, Object **child,
void (*check)(Object *, const char *,
Object *, Error **),
ObjectPropertyLinkFlags flag... | [
1,
0
] |
qemu | target/s390x/ioinst.c | void ioinst_handle_csch(S390CPU *cpu, uint64_t reg1)
{
int cssid, ssid, schid, m;
SubchDev *sch;
int ret = -ENODEV;
int cc;
if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {
program_interrupt(&cpu->env, PGM_OPERAND, 2);
return;
}
trace_ioinst_sch_id("csch", cssid, ssid,... | [
0,
0
] |
qemu | hw/i386/xen/xen_platform.c | int pci_piix3_xen_ide_unplug(DeviceState *dev)
{
PCIIDEState *pci_ide;
DriveInfo *di;
int i;
IDEDevice *idedev;
pci_ide = PCI_IDE(dev);
for (i = 0; i < 4; i++) {
di = drive_get_by_index(IF_IDE, i);
if (di != NULL && !di->media_cd) {
BlockBackend *blk = blk_by_legacy_dinfo(di);
... | [
1,
0
] |
FFmpeg | libavcodec/dcaenc.c | static void shift_history(DCAEncContext *c, const int32_t *input)
{
int k, ch;
for (k = 0; k < 512; k++)
for (ch = 0; ch < c->channels; ch++) {
const int chi = c->channel_order_tab[ch];
c->history[k][ch] = input[k * c->channels + chi];
}
} | [
0,
0
] |
FFmpeg | libavformat/network.c | int ff_socket(int af, int type, int proto)
{
int fd;
#ifdef SOCK_CLOEXEC
fd = socket(af, type | SOCK_CLOEXEC, proto);
if (fd == -1 && errno == EINVAL)
#endif
{
fd = socket(af, type, proto);
#if HAVE_FCNTL
if (fd != -1)
fcntl(fd, F_SETFD, FD_CLOEXEC);
#endif
}
return fd;
} | [
1,
0
] |
qemu | target-ppc/cpu.h | static void init_excp_602(CPUPPCState *env)
{
#if !defined(CONFIG_USER_ONLY)
env->excp_vectors[POWERPC_EXCP_RESET] = 0x00000100;
env->excp_vectors[POWERPC_EXCP_MCHECK] = 0x00000200;
env->excp_vectors[POWERPC_EXCP_DSI] = 0x00000300;
env->excp_vectors[POWERPC_EXCP_ISI] = 0x00000400;
env->excp_vectors[POW... | [
1,
0
] |
qemu | hw/xen_platform.c | static void unplug_nic(PCIBus *b, PCIDevice *d)
{
if (pci_get_word(d->config + PCI_CLASS_DEVICE) ==
PCI_CLASS_NETWORK_ETHERNET) {
qdev_unplug(&(d->qdev), NULL);
}
} | [
0,
0
] |
qemu | block/rbd.c | static char *qemu_rbd_parse_clientname(const char *conf, char *clientname)
{
const char *p = conf;
while (*p) {
int len;
const char *end = strchr(p, ':');
if (end) {
len = end - p;
} else {
len = strlen(p);
}
if (strncmp(p, "id=", 3) == 0) {
len -= 3;
strn... | [
1,
0
] |
qemu | tcg/aarch64/tcg-target.inc.c | static void tcg_reg_sync(TCGContext *s, TCGReg reg, TCGRegSet allocated_regs)
{
TCGTemp *ts = s->reg_to_temp[reg];
assert(ts->val_type == TEMP_VAL_REG);
if (!ts->mem_coherent && !ts->fixed_reg) {
if (!ts->mem_allocated) {
temp_allocate_frame(s, temp_idx(s, ts));
} else if (ts->indirect_reg) {... | [
1,
0
] |
qemu | fsdev/virtio-9p-marshal.c | static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
uint64_t off, uint32_t count,
struct iovec *sg, int cnt)
{
int i, to_copy;
ssize_t err = 0;
int write_count;
int64_t xattr_len;
size_t offset = 7;
xattr_len = fidp->fs... | [
1,
0
] |
FFmpeg | libavformat/4xm.c | static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams - 1];
MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
int entries, i;
print_atom("stsz", atom);
get_byte(pb); /* version */
get_byte(pb);
get_byte(pb);
get_byte(... | [
1,
0
] |
FFmpeg | libavcodec/vda_h264_dec.c | static int vdadec_decode(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt) {
VDADecoderContext *ctx = avctx->priv_data;
AVFrame *pic = data;
int ret;
ret = ff_h264_decoder.decode(avctx, data, got_frame, avpkt);
if (*got_frame) {
AVBufferRef *buffer = pic->buf[0];... | [
1,
0
] |
qemu | hw/intc/arm_gic.c | uint32_t gic_acknowledge_irq(GICState *s, int cpu)
{
int ret, irq, src;
int cm = 1 << cpu;
irq = s->current_pending[cpu];
if (irq == 1023
|| GIC_GET_PRIORITY(irq, cpu) >= s->running_priority[cpu]) {
DPRINTF("ACK no pending IRQ\n");
return 1023;
}
s->last_active[irq][cpu] = s->running_... | [
1,
0
] |
qemu | target-s390x/kvm.c | static int s390_cpu_initial_reset(S390CPU *cpu)
{
CPUState *cs = CPU(cpu);
CPUS390XState *env = &cpu->env;
int i;
s390_del_running_cpu(cpu);
if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL) < 0) {
perror("cannot init reset vcpu");
}
/* Manually zero out all registers */
cpu_synchronize_... | [
0,
0
] |
qemu | slirp/bootp.c | udp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr,
u_int lport, int flags)
{
struct sockaddr_in addr;
struct socket *so;
socklen_t addrlen = sizeof(struct sockaddr_in);
so = socreate(slirp);
if (!so) {
return NULL;
}
so->s = qemu_socket(AF_INET, SOCK_DGRAM, 0);
... | [
1,
0
] |
qemu | exec.c | static void breakpoint_invalidate(CPUState *env, target_ulong pc)
{
target_ulong phys_addr;
phys_addr = cpu_get_phys_page_debug(env, pc);
tb_invalidate_phys_page_range(phys_addr, phys_addr + 1, 0);
} | [
0,
0
] |
qemu | util/oslib-posix.c | void qemu_set_cloexec(int fd)
{
int f;
f = fcntl(fd, F_GETFD);
fcntl(fd, F_SETFD, f | FD_CLOEXEC);
} | [
0,
0
] |
qemu | net/netmap.c | static int netmap_can_send(void *opaque)
{
NetmapState *s = opaque;
return qemu_can_send_packet(&s->nc);
} | [
0,
0
] |
qemu | qemu-io.c | static int openfile(char *name, int flags, QDict *opts)
{
Error *local_err = NULL;
if (qemuio_blk) {
fprintf(stderr, "file open already, try 'help close'\n");
QDECREF(opts);
return 1;
}
qemuio_blk = blk_new_open("hda", name, NULL, opts, flags, &local_err);
if (!qemuio_blk) {
fprintf(s... | [
1,
0
] |
FFmpeg | libavfilter/avfiltergraph.c | static int pick_formats(AVFilterGraph *graph)
{
int i, j, ret;
int change;
do {
change = 0;
for (i = 0; i < graph->filter_count; i++) {
AVFilterContext *filter = graph->filters[i];
if (filter->nb_inputs) {
for (j = 0; j < filter->nb_inputs; j++) {
if (filter->inputs... | [
1,
0
] |
qemu | hw/intc/arm_gic.c | static void arm_gic_common_realize(DeviceState *dev, Error **errp) {
GICState *s = ARM_GIC_COMMON(dev);
int num_irq = s->num_irq;
if (s->num_cpu > GIC_NCPU) {
error_setg(errp, "requested %u CPUs exceeds GIC maximum %d", s->num_cpu,
GIC_NCPU);
s->num_irq += GIC_BASE_IRQ;
if (s->num_irq >... | [
1,
0
] |
qemu | hw/net/lance.c | static int lance_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
SysBusPCNetState *d = SYSBUS_PCNET(dev);
PCNetState *s = &d->state;
memory_region_init_io(&s->mmio, OBJECT(d), &lance_mem_ops, d,
"lance-mmio", 4);
qdev_init_gpio_in(dev, parent_lance_reset, 1);
sysbus... | [
1,
0
] |
qemu | block/qcow2.c | static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
int64_t offset, int count)
{
int ret;
BDRVQcow2State *s = bs->opaque;
if (!QEMU_IS_ALIGNED(offset | count, s->cluster_size)) {
assert(count < s->cluster_size);
return -ENOTSUP;
}
qemu_co_m... | [
1,
0
] |
qemu | hw/ppc/Makefile.objs | void stb_tce(VIOsPAPRDevice *dev, uint64_t taddr, uint8_t val)
{
spapr_tce_dma_write(dev, taddr, &val, sizeof(val));
} | [
1,
0
] |
FFmpeg | libavformat/hlsenc.c | static int replace_int_data_in_filename(char *buf, int buf_size,
const char *filename, char placeholder,
int64_t number)
{
const char *p;
char *q, buf1[20], c;
int nd, len, addchar_count;
int found_count = 0;
q = buf;
p =... | [
1,
0
] |
FFmpeg | ffmpeg.c | int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den,
int64_t max) {
AVRational a0 = {0, 1}, a1 = {1, 0};
int sign = (num < 0) ^ (den < 0);
int64_t gcd = av_gcd(FFABS(num), FFABS(den));
if (gcd) {
num = FFABS(num) / gcd;
den = FFABS(den) / gcd;
}
if (num <= max && ... | [
1,
0
] |
FFmpeg | tools/trasher.c | int main(int argc, char **argv)
{
FILE *f = fopen(argv[1], "rb+");
int count = atoi(argv[2]);
int maxburst = atoi(argv[3]);
int length;
srand(time(0));
fseek(f, 0, SEEK_END);
length = ftell(f);
fseek(f, 0, SEEK_SET);
while (count--) {
int burst = 1 + random() * (uint64_t)(abs(maxburst) ... | [
0,
0
] |
FFmpeg | libavcodec/jpeg2000dec.c | static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
{
uint8_t Stlm, ST, SP, tile_tlm, i;
bytestream_get_byte(&s->buf); /* Ztlm: skipped */
Stlm = bytestream_get_byte(&s->buf);
// too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
ST = (Stlm >> 4) & 0x03;
// TODO: Manage case of ST =... | [
1,
1
] |
qemu | tcg/tcg.c | static inline int tcg_temp_new_internal(TCGType type, int temp_local)
{
TCGContext *s = &tcg_ctx;
TCGTemp *ts;
int idx, k;
k = type + (temp_local ? TCG_TYPE_COUNT : 0);
idx = find_first_bit(s->free_temps[k].l, TCG_MAX_TEMPS);
if (idx < TCG_MAX_TEMPS) {
/* There is already an available temp with ... | [
0,
0
] |
qemu | target-arm/helper.c | uint32_t HELPER(get_r13_banked)(CPUState *env, uint32_t mode)
{
return env->banked_r13[bank_number(mode)];
} | [
0,
0
] |
FFmpeg | libavcodec/wmaenc.c | static void apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
{
WMACodecContext *s = avctx->priv_data;
float **audio = (float **)frame->extended_data;
int len = frame->nb_samples;
int window_index = s->frame_len_bits - s->block_len_bits;
FFTContext *mdct = &s->mdct_ctx[window_index];
... | [
1,
0
] |
qemu | net/tap.c | int net_init_bridge(const NetClientOptions *opts, const char *name,
NetClientState *peer, Error **errp)
{
/* FIXME error_setg(errp, ...) on failure */
const NetdevBridgeOptions *bridge;
const char *helper, *br;
TAPState *s;
int fd, vnet_hdr;
assert(opts->kind == NET_CLIENT_OPTION... | [
1,
1
] |
FFmpeg | libavcodec/h264.c | static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale) {
return chroma_qp[av_clip(qscale + chroma_qp_index_offset, 0, 51)];
} | [
1,
0
] |
FFmpeg | libavformat/aiffdec.c | static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
{
int ret, size, bps;
// AVStream *st = s->streams[0];
size = RAW_SAMPLES * s->streams[0]->codec->block_align;
ret = av_get_packet(s->pb, pkt, size);
pkt->stream_index = 0;
if (ret < 0)
return ret;
bps = av_get_bits_per_sample(s... | [
1,
0
] |
FFmpeg | libswscale/output.c | yuv2ya8_2_c(SwsContext *c, const int16_t *buf[2],
const int16_t *ubuf[2], const int16_t *vbuf[2],
const int16_t *abuf[2], uint8_t *dest, int dstW,
int yalpha, int uvalpha, int y)
{
int hasAlpha = abuf[0] && abuf[1];
const int16_t *buf0 = buf[0], *buf1 = buf[1],
... | [
1,
0
] |
FFmpeg | libavformat/rtmppkt.c | int ff_amf_tag_size(const uint8_t *data, const uint8_t *data_end)
{
const uint8_t *base = data;
if (data >= data_end)
return -1;
switch (*data++) {
case AMF_DATA_TYPE_NUMBER:
return 9;
case AMF_DATA_TYPE_BOOL:
return 2;
case AMF_DATA_TYPE_STRING:
return 3 + AV_RB16(data);
case AMF... | [
1,
0
] |
qemu | hw/core/qdev.c | static void device_unparent(Object *obj)
{
DeviceState *dev = DEVICE(obj);
BusState *bus;
if (dev->realized) {
object_property_set_bool(obj, false, "realized", NULL);
}
while (dev->num_child_bus) {
bus = QLIST_FIRST(&dev->child_bus);
object_unparent(OBJECT(bus));
}
if (dev->parent_bus... | [
1,
0
] |
qemu | block.c | const char *bdrv_get_node_name(const BlockDriverState *bs)
{
return bs->node_name;
} | [
0,
0
] |
qemu | hw/sparc32_dma.c | static void dma_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
{
DMAState *s = opaque;
uint32_t saddr;
saddr = (addr & DMA_MASK) >> 2;
DPRINTF("write dmareg " TARGET_FMT_plx ": 0x%8.8x -> 0x%8.8x\n", addr,
s->dmaregs[saddr], val);
switch (saddr) {
case 0:
if (val & DM... | [
1,
0
] |
qemu | target/s390x/cpu.c | void s390_sclp_extint(uint32_t parm)
{
if (kvm_enabled()) {
kvm_s390_service_interrupt(parm);
} else {
S390CPU *dummy_cpu = s390_cpu_addr2state(0);
cpu_inject_ext(dummy_cpu, EXT_SERVICE, parm, 0);
}
} | [
0,
0
] |
FFmpeg | ffmpeg.c | static int check_init_output_file(OutputFile *of, int file_index)
{
int ret, i;
for (i = 0; i < of->ctx->nb_streams; i++) {
OutputStream *ost = output_streams[of->ost_index + i];
if (!ost->initialized)
return 0;
}
of->ctx->interrupt_callback = int_cb;
ret = avformat_write_header(of->ctx,... | [
1,
0
] |
qemu | net/colo-compare.c | static void colo_compare_connection(void *opaque, void *user_data)
{
CompareState *s = user_data;
Connection *conn = opaque;
Packet *pkt = NULL;
GList *result = NULL;
int ret;
while (!g_queue_is_empty(&conn->primary_list) &&
!g_queue_is_empty(&conn->secondary_list)) {
qemu_mutex_lock(&... | [
0,
1
] |
qemu | linux-user/elfload.c | static void setup_rt_frame(int usig, struct emulated_sigaction *ka,
target_siginfo_t *info,
target_sigset_t *set, CPUState *env)
{
struct rt_sigframe *frame = get_sigframe(ka, env, sizeof(*frame));
int err = 0;
#if 0
if (!access_ok(VERIFY_WRITE, frame, s... | [
1,
0
] |
qemu | exec-i386.c | int cpu_x86_signal_handler(int host_signum, struct siginfo *info,
void *puc)
{
uint32_t *regs = (uint32_t *)(info + 1);
void *sigmask = (regs + 20);
unsigned long pc;
int is_write;
uint32_t insn;
/* XXX: is there a standard glibc define ? */
pc = regs[1];
/* XXX: nee... | [
1,
1
] |
qemu | block/bochs.c | static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
{
BDRVBochsState *s = bs->opaque;
int64_t offset = sector_num * 512;
int64_t extent_index, extent_offset, bitmap_offset;
char bitmap_entry;
// seek to sector
extent_index = offset / s->extent_size;
extent_offset = (offset % s-... | [
1,
0
] |
FFmpeg | libavcodec/Makefile | av_cold void ff_wmv2_common_init(Wmv2Context *w) {
MpegEncContext *const s = &w->s;
ff_init_scantable(s->dsp.idct_permutation, &w->abt_scantable[0],
ff_wmv2_scantableA);
ff_init_scantable(s->dsp.idct_permutation, &w->abt_scantable[1],
ff_wmv2_scantableB);
} | [
1,
0
] |
qemu | net/tap-linux.c | void tap_fd_set_offload(int fd, int csum, int tso4, int tso6, int ecn,
int ufo) {
unsigned int offload = 0;
if (csum) {
offload |= TUN_F_CSUM;
if (tso4)
offload |= TUN_F_TSO4;
if (tso6)
offload |= TUN_F_TSO6;
if ((tso4 || tso6) && ecn)
offload |= TUN_F_TSO_E... | [
1,
0
] |
FFmpeg | libavcodec/dsputil.h | static av_always_inline int vc1_filter_line(uint8_t *src, int stride, int pq) {
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
int a0 = (2 * (src[-2 * stride] - src[1 * stride]) -
5 * (src[-1 * stride] - src[0 * stride]) + 4) >>
3;
int a0_sign = a0 >> 31; /* Store sign */
a0 = (a0 ^ a0_sign... | [
1,
0
] |
FFmpeg | libavcodec/avpacket.c | uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
int size)
{
int elems = pkt->side_data_elems;
if ((unsigned)elems + 1 > INT_MAX / sizeof(*pkt->side_data))
return NULL;
if ((unsigned)size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
retur... | [
1,
0
] |
qemu | tests/test-thread-pool.c | static void test_submit_aio(void)
{
WorkerTestData data = {.n = 0, .ret = -EINPROGRESS};
data.aiocb = thread_pool_submit_aio(pool, worker_cb, &data,
done_cb, &data);
/* The callbacks are not called until after the first wait. */
active = 1;
g_assert_cmpint(data.re... | [
1,
0
] |
FFmpeg | libavcodec/huffyuv.c | static int common_init(AVCodecContext *avctx) {
HYuvContext *s = avctx->priv_data;
int i;
s->avctx = avctx;
s->flags = avctx->flags;
dsputil_init(&s->dsp, avctx);
s->width = avctx->width;
s->height = avctx->height;
assert(s->width > 0 && s->height > 0);
for (i = 0; i < 3; i++) {
s->temp[... | [
1,
0
] |
FFmpeg | libavcodec/ffv1dec.c | static void decode_plane(FFV1Context *s, uint8_t *src,
int w, int h, int stride, int plane_index,
int pixel_stride)
{
int x, y;
int16_t *sample[2];
sample[0] = s->sample_buffer + 3;
sample[1] = s->sample_buffer + w + 6 + 3;
s->run_index = 0;
memset(... | [
1,
1
] |
FFmpeg | libavformat/wav.c | static int wav_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
int size;
unsigned int tag;
ByteIOContext *pb = s->pb;
AVStream *st;
WAVContext *wav = s->priv_data;
/* check RIFF header */
tag = get_le32(pb);
if (tag != MKTAG('R', 'I', 'F', 'F'))
return... | [
1,
0
] |
qemu | hw/omap_gpmc.c | struct omap_gpmc_s *omap_gpmc_init(target_phys_addr_t base, qemu_irq irq)
{
struct omap_gpmc_s *s = (struct omap_gpmc_s *)
g_malloc0(sizeof(struct omap_gpmc_s));
memory_region_init_io(&s->iomem, &omap_gpmc_ops, s, "omap-gpmc", 0x1000);
memory_region_add_subregion(get_system_memory(), base, &s->iomem);
... | [
1,
0
] |
FFmpeg | libavutil/hwcontext_vdpau.c | static int vdpau_frames_init(AVHWFramesContext *ctx)
{
VDPAUDeviceContext *device_priv = ctx->device_ctx->internal->priv;
VDPAUFramesContext *priv = ctx->internal->priv;
int i;
switch (ctx->sw_format) {
case AV_PIX_FMT_YUV420P:
priv->chroma_type = VDP_CHROMA_TYPE_420;
break;
case AV_PIX_FMT_Y... | [
1,
0
] |
qemu | target-ppc/helper.c | void OPPROTO op_divd(void)
{
if (unlikely(((int64_t)T0 == INT64_MIN && (int64_t)T1 == -1) ||
(int64_t)T1 == 0)) {
T0 = (int64_t)((-1ULL) * ((uint64_t)T0 >> 63));
} else {
T0 = (int64_t)T0 / (int64_t)T1;
}
RETURN();
} | [
1,
0
] |
FFmpeg | ffserver.c | static void new_connection(int server_fd, int is_rtsp)
{
struct sockaddr_in from_addr;
int fd, len;
HTTPContext *c = NULL;
len = sizeof(from_addr);
fd = accept(server_fd, (struct sockaddr *)&from_addr,
&len);
if (fd < 0)
return;
fcntl(fd, F_SETFL, O_NONBLOCK);
/* XXX: should... | [
1,
1
] |
qemu | cutils.c | void qemu_iovec_destroy(QEMUIOVector *qiov)
{
assert(qiov->nalloc != -1);
g_free(qiov->iov);
} | [
1,
0
] |
qemu | hw/dma/rc4030.c | static void rc4030_dma_tt_write(void *opaque, hwaddr addr, uint64_t data,
unsigned int size)
{
rc4030State *s = opaque;
/* write memory */
memcpy(memory_region_get_ram_ptr(&s->dma_tt) + addr, &data, size);
/* update dma address space (only if frame field has been written) *... | [
1,
0
] |
qemu | hw/block/dataplane/virtio-blk.c | bool virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *blk,
VirtIOBlockDataPlane **dataplane) {
VirtIOBlockDataPlane *s;
int fd;
*dataplane = NULL;
if (!blk->data_plane) {
return true;
if (blk->scsi) {
error_report("device is incompatible with x-data... | [
1,
0
] |
FFmpeg | libavformat/srtdec.c | static int64_t get_pts(const char *buf, int *duration)
{
int i, hour, min, sec, hsec;
int he, me, se, mse;
for (i = 0; i < 2; i++) {
int64_t start, end;
if (sscanf(buf, "%d:%2d:%2d%*1[,.]%3d --> %d:%2d:%2d%*1[,.]%3d",
&hour, &min, &sec, &hsec, &he, &me, &se, &mse) == 8) {
min ... | [
1,
0
] |
qemu | target-cris/op_helper.c | void helper_movl_sreg_reg(uint32_t sreg, uint32_t reg)
{
uint32_t srs;
srs = env->pregs[PR_SRS];
srs &= 3;
env->sregs[srs][sreg] = env->regs[reg];
#if !defined(CONFIG_USER_ONLY)
if (srs == 1 || srs == 2) {
if (sreg == 6) {
/* Writes to tlb-hi write to mm_cause as a side
effect. *... | [
1,
0
] |
qemu | hw/eccmemctl.c | static void ecc_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
{
printf("ECC: Unsupported write 0x" TARGET_FMT_plx " %02x\n",
addr, val & 0xff);
} | [
0,
0
] |
FFmpeg | libswscale/Makefile | static void RENAME(lumRangeToJpeg)(int16_t *dst, int width)
{
int i;
for (i = 0; i < width; i++)
dst[i] = (FFMIN(dst[i], 30189) * 19077 - 39057361) >> 14;
} | [
0,
0
] |
qemu | block/nbd.c | static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs)
{
BDRVQcow2State *s = bs->opaque;
ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);
*spec_info = (ImageInfoSpecific){
.kind = IMAGE_INFO_SPECIFIC_KIND_QCOW2,
{
.qcow2 = g_new(ImageInfoSpecificQCow2, 1),
... | [
0,
0
] |
FFmpeg | libavcodec/aacenc.c | static int amr_wb_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr)
{
AMRWBContext *s = avctx->priv_data;
const int16_t *samples = (const int16_t *)frame->data[0];
int size, ret;
if ((ret = ff_alloc_packet2(avctx, avpkt, MAX_PACK... | [
1,
0
] |
FFmpeg | libavcodec/avcodec.h | void ff_fix_long_b_mvs(MpegEncContext *s, int16_t (*mv_table)[2], int f_code,
int type)
{
int y;
uint8_t *fcode_tab = s->fcode_tab;
// RAL: 8 in MPEG-1, 16 in MPEG-4
int range = (((s->codec_id == CODEC_ID_MPEG1VIDEO) ? 8 : 16) << f_code);
/* clip / convert to intra 16x16 type MVs ... | [
1,
0
] |
qemu | linux-user/signal.c | static void setup_frame(int usig, struct emulated_sigaction *ka,
target_sigset_t *set, CPUState *regs)
{
struct sigframe *frame;
abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
int i, err = 0;
if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
return;
... | [
1,
0
] |
qemu | Makefile.objs | int qemu_uuid_parse(const char *str, uint8_t *uuid)
{
int ret;
if (strlen(str) != 36)
return -1;
ret =
sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
&uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
&uuid[10], &uuid[11], &uuid[12], &uuid[13], &u... | [
1,
0
] |
qemu | HACKING | static uint64_t error_mem_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
abort();
} | [
0,
0
] |
qemu | hw/ide/pci.c | static int bmdma_prepare_buf(IDEDMA *dma, int is_write)
{
BMDMAState *bm = DO_UPCAST(BMDMAState, dma, dma);
IDEState *s = bmdma_active_if(bm);
struct {
uint32_t addr;
uint32_t size;
} prd;
int l, len;
qemu_sglist_init(&s->sg, s->nsector / (BMDMA_PAGE_SIZE / 512) + 1);
s->io_buffer_size =... | [
1,
0
] |
qemu | util/qemu-option.c | static bool qemu_opt_get_bool_helper(QemuOpts *opts, const char *name,
bool defval, bool del)
{
QemuOpt *opt = qemu_opt_find(opts, name);
bool ret = defval;
if (opt == NULL) {
const QemuOptDesc *desc = find_desc_by_name(opts->list->desc, name);
if (desc && desc-... | [
1,
0
] |
qemu | hw/s390x/s390-virtio-ccw.c | S390CPU *s390x_new_cpu(const char *cpu_model, uint32_t core_id, Error **errp)
{
S390CPU *cpu;
Error *err = NULL;
cpu = cpu_s390x_create(cpu_model, &err);
if (err != NULL) {
goto out;
}
object_property_set_int(OBJECT(cpu), core_id, "core-id", &err);
if (err != NULL) {
goto out;
}
obje... | [
0,
0
] |
qemu | hw/acpi/nvdimm.c | static uint32_t nvdimm_get_max_xfer_label_size(void)
{
uint32_t max_get_size, max_set_size, dsm_memory_size = 4096;
/*
* the max data ACPI can read one time which is transferred by
* the response of 'Get Namespace Label Data' function.
*/
max_get_size = dsm_memory_size - sizeof(NvdimmFuncGetLabelD... | [
1,
0
] |
qemu | Makefile.objs | aio_compute_timeout(AioContext *ctx)
{
int64_t deadline;
int timeout = -1;
QEMUBH *bh;
for (bh = atomic_rcu_read(&ctx->first_bh); bh;
bh = atomic_rcu_read(&bh->next)) {
if (bh->scheduled) {
if (bh->idle) {
/* idle bottom halves will be polled at least
* every 10ms */
... | [
0,
0
] |
qemu | migration/migration.c | static bool ufd_version_check(int ufd)
{
struct uffdio_api api_struct;
uint64_t ioctl_mask;
api_struct.api = UFFD_API;
api_struct.features = 0;
if (ioctl(ufd, UFFDIO_API, &api_struct)) {
error_report("postcopy_ram_supported_by_host: UFFDIO_API failed: %s",
strerror(errno));
r... | [
1,
0
] |
qemu | hw/i386/acpi-build.c | static void string_output_append(StringOutputVisitor *sov, int64_t a)
{
Range *r = g_malloc0(sizeof(*r));
r->begin = a;
r->end = a + 1;
sov->ranges = range_list_insert(sov->ranges, r);
} | [
0,
0
] |
qemu | target-arm/cpu.c | static void aarch64_cpu_register(const ARMCPUInfo *info)
{
TypeInfo type_info = {
.parent = TYPE_AARCH64_CPU,
.instance_size = sizeof(ARMCPU),
.instance_init = info->initfn,
.class_size = sizeof(ARMCPUClass),
.class_init = info->class_init,
};
/* TODO: drop when we support m... | [
1,
1
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.