Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
qemu | block.c | static int set_dirty_tracking(void)
{
BlkMigDevState *bmds;
int ret;
QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
bmds->dirty_bitmap = bdrv_create_dirty_bitmap(bmds->bs, BLOCK_SIZE,
NULL);
if (!bmds->dirty_bitmap) {
ret = -errn... | [
0,
0
] |
qemu | hw/scsi-bus.c | static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev,
uint8_t *buf)
{
switch (buf[0]) {
/* stream commands */
case ERASE_12:
case ERASE_16:
cmd->xfer = 0;
break;
case READ_6:
case READ_REVERSE:
case RECOVER_BUFFERED_DATA:
case WRITE_6... | [
0,
0
] |
qemu | target-microblaze/cpu-qom.h | static inline TCGv *compute_ldst_addr(DisasContext *dc, TCGv *t)
{
unsigned int extimm = dc->tb_flags & IMM_FLAG;
/* Should be set to one if r1 is used by loadstores. */
int stackprot = 0;
/* All load/stores use ra. */
if (dc->ra == 1) {
stackprot = 1;
}
/* Treat the common cases first. */
... | [
1,
0
] |
qemu | tcg/aarch64/tcg-target.inc.c | static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1,
intptr_t arg2)
{
uint8_t *old_code_ptr = s->code_ptr;
if (type == TCG_TYPE_I32) {
tcg_out_op_t(s, INDEX_op_ld_i32);
tcg_out_r(s, ret);
tcg_out_r(s, arg1);
tcg_out32(s, arg2);
} else {
... | [
0,
0
] |
qemu | hw/omap1.c | static void sm501_palette_write(void *opaque,
target_phys_addr_t addr, uint32_t value)
{
SM501State *s = (SM501State *)opaque;
SM501_DPRINTF("sm501 palette write addr=%x, val=%x\n",
(int)addr, value);
/* TODO : consider BYTE/WORD access */
/* TODO : conside... | [
1,
1
] |
FFmpeg | libavfilter/vf_tile.c | static int draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
{
AVFilterContext *ctx = inlink->dst;
TileContext *tile = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
unsigned x0, y0;
get_current_tile_pos(ctx, &x0, &y0);
ff_copy_rectangle2(&tile->draw,
outlink->o... | [
1,
1
] |
qemu | cpu-exec.c | void cpu_check_irqs(CPUState *env)
{
uint32_t pil = env->pil_in | (env->softint & ~SOFTINT_TIMER) |
((env->softint & SOFTINT_TIMER) << 14);
if (pil && (env->interrupt_index == 0 ||
(env->interrupt_index & ~15) == TT_EXTINT)) {
unsigned int i;
for (i = 15; i > 0; i--) {
... | [
1,
0
] |
qemu | tests/Makefile.include | static void test_drive_del_device_del(void)
{
/* Start with a drive used by a device that unplugs instantaneously */
qtest_start("-drive if=none,id=drive0,file=null-co://,format=raw"
" -device virtio-scsi-pci"
" -device scsi-hd,drive=drive0,id=dev0");
/*
* Delete the drive, a... | [
0,
0
] |
qemu | hw/xen/xen_pt.h | static int xen_pt_msgdata_reg_write(XenPCIPassthroughState *s,
XenPTReg *cfg_entry, uint16_t *val,
uint16_t dev_value, uint16_t valid_mask)
{
XenPTRegInfo *reg = cfg_entry->reg;
XenPTMSI *msi = s->msi;
uint16_t writable_mask = 0;
uin... | [
0,
0
] |
qemu | target/s390x/helper.h | void HELPER(cdsg)(CPUS390XState *env, uint64_t addr,
uint32_t r1, uint32_t r3)
{
uintptr_t ra = GETPC();
Int128 cmpv = int128_make128(env->regs[r1 + 1], env->regs[r1]);
Int128 newv = int128_make128(env->regs[r3 + 1], env->regs[r3]);
Int128 oldv;
bool fail;
if (parallel_cpus) {
#if... | [
0,
0
] |
qemu | hw/net/virtio-net.c | bool qemu_peer_has_vnet_hdr_len(NetClientState *nc, int len)
{
if (!nc->peer || !nc->peer->info->has_vnet_hdr_len) {
return false;
}
return nc->peer->info->has_vnet_hdr_len(nc->peer, len);
} | [
1,
0
] |
qemu | exec.c | ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host,
MemoryRegion *mr)
{
RAMBlock *new_block;
size = TARGET_PAGE_ALIGN(size);
new_block = g_malloc0(sizeof(*new_block));
new_block->mr = mr;
new_block->offset = find_ram_offset(size);
if (host) {
new_b... | [
1,
0
] |
qemu | hw/misc/pvpanic.c | static void unmanageable_intercept(S390CPU *cpu, const char *str, int pswoffset)
{
CPUState *cs = CPU(cpu);
error_report("Unmanageable %s! CPU%i new PSW: 0x%016lx:%016lx",
str, cs->cpu_index, ldq_phys(cs->as, cpu->env.psa + pswoffset),
ldq_phys(cs->as, cpu->env.psa + pswoffset + 8... | [
1,
0
] |
qemu | net/queue.c | NetQueue *qemu_new_net_queue(void *opaque)
{
NetQueue *queue;
queue = g_malloc0(sizeof(NetQueue));
queue->opaque = opaque;
QTAILQ_INIT(&queue->packets);
queue->delivering = 0;
return queue;
} | [
1,
0
] |
FFmpeg | libavcodec/pthread.c | static void park_frame_worker_threads(FrameThreadContext *fctx,
int thread_count)
{
int i;
for (i = 0; i < thread_count; i++) {
PerThreadContext *p = &fctx->threads[i];
if (p->state != STATE_INPUT_READY) {
pthread_mutex_lock(&p->progress_mutex);
while... | [
1,
0
] |
qemu | target-mips/dsp_helper.c | static inline uint16_t mipsdsp_trunc16_sat16_round(int32_t a,
CPUMIPSState *env)
{
int64_t temp;
temp = (int32_t)a + 0x00008000;
if (a > (int)0x7fff8000) {
temp = 0x7FFFFFFF;
set_DSPControl_overflow_flag(1, 22, env);
}
return (temp >> 16) & 0x... | [
1,
0
] |
FFmpeg | configure | void ff_mlp_init_x86(DSPContext *c, AVCodecContext *avctx)
{
#if HAVE_7REGS && HAVE_TEN_OPERANDS
c->mlp_filter_channel = mlp_filter_channel_x86;
#endif
} | [
1,
0
] |
FFmpeg | libavcodec/opus_pvq.c | static void celt_pvq_search(float *X, int *y, int K, int N)
{
int i;
float res = 0.0f, y_norm = 0.0f, xy_norm = 0.0f;
for (i = 0; i < N; i++)
res += FFABS(X[i]);
res = K / res;
for (i = 0; i < N; i++) {
y[i] = lrintf(res * X[i]);
y_norm += y[i] * y[i];
xy_norm += y[i] * X[i];
K ... | [
1,
1
] |
qemu | target-ppc/helper.h | static void gen_spr_thrm(CPUPPCState *env)
{
/* Thermal management */
/* XXX : not implemented */
spr_register(env, SPR_THRM1, "THRM1",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
/* XXX : not implemented */
spr_register... | [
1,
1
] |
FFmpeg | libavcodec/ppc/mpegvideoencdsp.c | static int pix_sum_altivec(uint8_t *pix, int line_size)
{
int i, s;
const vector unsigned int zero =
(const vector unsigned int)vec_splat_u32(0);
vector unsigned int sad = (vector unsigned int)vec_splat_u32(0);
vector signed int sumdiffs;
for (i = 0; i < 16; i++) {
/* Read the potentially un... | [
1,
0
] |
qemu | block.c | int bdrv_create(BlockDriver *drv, const char *filename,
QemuOpts *opts, Error **errp)
{
int ret;
Coroutine *co;
CreateCo cco = {
.drv = drv,
.filename = g_strdup(filename),
.opts = opts,
.ret = NOT_DONE,
.err = NULL,
};
if (!drv->bdrv_create) {
er... | [
1,
0
] |
qemu | Makefile.objs | ssize_t qsb_get_buffer(const QEMUSizedBuffer *qsb, off_t start,
size_t count, uint8_t *buffer)
{
const struct iovec *iov;
size_t to_copy, all_copy;
ssize_t index;
off_t s_off;
off_t d_off = 0;
char *s;
if (start > qsb->used) {
return 0;
}
all_copy = qsb->used - st... | [
1,
0
] |
qemu | hw/vfio/pci-quirks.c | static void vfio_probe_ati_bar4_quirk(VFIOPCIDevice *vdev, int nr)
{
VFIOQuirk *quirk;
VFIOConfigWindowQuirk *window;
/* This windows doesn't seem to be used except by legacy VGA code */
if (!vfio_pci_is(vdev, PCI_VENDOR_ID_ATI, PCI_ANY_ID) ||
!vdev->has_vga || nr != 4) {
return;
}
quirk =... | [
1,
0
] |
qemu | vl.c | static void smp_parse(QemuOpts *opts)
{
if (opts) {
unsigned cpus = qemu_opt_get_number(opts, "cpus", 0);
unsigned sockets = qemu_opt_get_number(opts, "sockets", 0);
unsigned cores = qemu_opt_get_number(opts, "cores", 0);
unsigned threads = qemu_opt_get_number(opts, "threads", 0);
/* comput... | [
1,
0
] |
FFmpeg | libavcodec/roqvideoenc.c | static av_cold int roq_encode_init(AVCodecContext *avctx) {
RoqContext *enc = avctx->priv_data;
av_lfg_init(&enc->randctx, 1);
enc->framesSinceKeyframe = 0;
if ((avctx->width & 0xf) || (avctx->height & 0xf)) {
av_log(avctx, AV_LOG_ERROR, "Dimensions must be divisible by 16\n");
return AVERROR(EINVAL);
... | [
1,
0
] |
FFmpeg | libavcodec/mpegvideo.c | int ff_mpv_frame_size_alloc(MpegEncContext *s, int linesize)
{
int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
// edge emu needs blocksize + filter length - 1
// (= 17x17 for halfpel / 21x21 for h264)
// VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
// at uvlinesize. It support... | [
1,
0
] |
qemu | block.c | void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors)
{
BdrvDirtyBitmap *bitmap;
QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) {
hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
}
} | [
1,
0
] |
qemu | hw/pci/pci.c | static void pci_device_class_init(ObjectClass *klass, void *data)
{
DeviceClass *k = DEVICE_CLASS(klass);
k->init = pci_qdev_init;
k->exit = pci_unregister_device;
k->bus_type = TYPE_PCI_BUS;
k->props = pci_props;
} | [
1,
0
] |
qemu | hw/qdev-properties.c | static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len)
{
DriveInfo **ptr = qdev_get_prop_ptr(dev, prop);
return snprintf(dest, len, "%s", (*ptr)->id);
} | [
1,
0
] |
FFmpeg | libavcodec/dsputil.c | static void vc1_inv_trans_8x4_dc_c(uint8_t *dest, int linesize, DCTELEM *block)
{
int i;
int dc = block[0];
const uint8_t *cm;
dc = (3 * dc + 1) >> 1;
dc = (17 * dc + 64) >> 7;
cm = ff_cropTbl + MAX_NEG_CROP + dc;
for (i = 0; i < 4; i++) {
dest[0] = cm[dest[0]];
dest[1] = cm[dest[1]];
... | [
1,
0
] |
FFmpeg | libavformat/movenc.c | static int check_pkt(AVFormatContext *s, AVPacket *pkt)
{
MOVMuxContext *mov = s->priv_data;
MOVTrack *trk = &mov->tracks[pkt->stream_index];
if (trk->entry) {
int64_t duration = pkt->dts - trk->cluster[trk->entry - 1].dts;
if (duration < 0 || duration > INT_MAX) {
av_log(s, AV_LOG_ERROR,
... | [
1,
0
] |
qemu | Makefile.objs | void qemu_start_incoming_migration(const char *uri, Error **errp)
{
const char *p;
if (strstart(uri, "tcp:", &p))
tcp_start_incoming_migration(p, errp);
#ifdef CONFIG_RDMA
else if (strstart(uri, "rdma:", &p))
rdma_start_incoming_migration(p, errp);
#endif
#if !defined(WIN32)
else if (strstart(... | [
1,
0
] |
qemu | target-ppc/cpu.h | void OPPROTO op_subfo(void)
{
do_subfo();
RETURN();
} | [
1,
0
] |
FFmpeg | libavcodec/vc1dsp.c | static always_inline uint8_t vc1_mspel_filter(const uint8_t *src, int stride,
int mode, int r)
{
switch (mode) {
case 0: // no shift
return src[0];
case 1: // 1/4 shift
return (-4 * src[-stride] + 53 * src[0] + 18 * src[stride] -
3 * src[stri... | [
1,
0
] |
FFmpeg | libavcodec/sbrdsp_fixed.c | static void sbr_hf_g_filt_c(int (*Y)[2], const int (*X_high)[40][2],
const SoftFloat *g_filt, int m_max, intptr_t ixh)
{
int m;
int64_t accu;
for (m = 0; m < m_max; m++) {
int64_t r = 1LL << (22 - g_filt[m].exp);
accu = (int64_t)X_high[m][ixh][0] * ((g_filt[m].mant + 0x4... | [
1,
0
] |
qemu | qapi-schema-guest.json | static void usage(const char *cmd)
{
printf(
"Usage: %s [-m <method> -p <path>] [<options>]\n"
"QEMU Guest Agent %s\n"
"\n"
" -m, --method transport method: one of unix-listen, "
"virtio-serial, or\n"
" isa-serial (virtio-serial is the default)\n"
... | [
1,
0
] |
FFmpeg | libavformat/gxf.c | static int gxf_packet(AVFormatContext *s, AVPacket *pkt) {
ByteIOContext *pb = s->pb;
pkt_type_t pkt_type;
int pkt_len;
while (!url_feof(pb)) {
int track_type, track_id, ret;
int field_nr;
if (!parse_packet_header(pb, &pkt_type, &pkt_len)) {
if (!url_feof(pb))
av_log(s, AV_LOG... | [
1,
0
] |
qemu | tcg/tcg.c | TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name)
{
int idx;
idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name);
return MAKE_TCGV_I32(idx);
} | [
0,
0
] |
qemu | acl.c | static void ioreq_release(struct ioreq *ioreq)
{
struct XenBlkDev *blkdev = ioreq->blkdev;
LIST_REMOVE(ioreq, list);
memset(ioreq, 0, sizeof(*ioreq));
ioreq->blkdev = blkdev;
LIST_INSERT_HEAD(&blkdev->freelist, ioreq, list);
blkdev->requests_finished--;
} | [
1,
0
] |
qemu | target-sparc/fop_helper.c | static inline void set_fsr(CPUSPARCState *env)
{
int rnd_mode;
switch (env->fsr & FSR_RD_MASK) {
case FSR_RD_NEAREST:
rnd_mode = float_round_nearest_even;
break;
default:
case FSR_RD_ZERO:
rnd_mode = float_round_to_zero;
break;
case FSR_RD_POS:
rnd_mode = float_round_up;
... | [
0,
0
] |
qemu | target/s390x/misc_helper.c | void HELPER(stfl)(CPUS390XState *env)
{
uint64_t words[MAX_STFL_WORDS];
LowCore *lowcore;
lowcore = cpu_map_lowcore(env);
do_stfle(env, words);
lowcore->stfl_fac_list = cpu_to_be32(words[0] >> 32);
cpu_unmap_lowcore(lowcore);
} | [
0,
0
] |
qemu | Makefile.objs | static int get_int64(QEMUFile *f, void *pv, size_t size)
{
int64_t *v = pv;
qemu_get_sbe64s(f, v);
return 0;
} | [
1,
0
] |
FFmpeg | libavformat/pmpdec.c | static int pmp_packet(AVFormatContext *s, AVPacket *pkt)
{
PMPContext *pmp = s->priv_data;
AVIOContext *pb = s->pb;
int ret = 0;
int i;
if (url_feof(pb))
return AVERROR_EOF;
if (pmp->cur_stream == 0) {
int num_packets;
pmp->audio_packets = avio_r8(pb);
num_packets = (pmp->num_stre... | [
1,
1
] |
qemu | hw/core/loader.c | static void acpi_build_update(void *build_opaque, uint32_t offset)
{
AcpiBuildState *build_state = build_opaque;
AcpiBuildTables tables;
/* No state to update or already patched? Nothing to do. */
if (!build_state || build_state->patched) {
return;
}
build_state->patched = 1;
acpi_build_tables... | [
1,
0
] |
FFmpeg | libavcodec/imgconvert.c | int av_picture_crop(AVPicture *dst, const AVPicture *src,
enum PixelFormat pix_fmt, int top_band, int left_band)
{
int y_shift;
int x_shift;
if (pix_fmt < 0 || pix_fmt >= PIX_FMT_NB)
return -1;
y_shift = av_pix_fmt_descriptors[pix_fmt].log2_chroma_h;
x_shift = av_pix_fmt_descri... | [
1,
1
] |
FFmpeg | libavcodec/wavpack.c | static int wv_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
WVContext *wc = s->priv_data;
int ret, samples;
if (url_feof(&s->pb))
return -EIO;
if (wc->block_parsed) {
if (wv_read_block_header(s, &s->pb) < 0)
return -1;
}
samples = LE_32(wc->extra);
/* ... | [
1,
0
] |
FFmpeg | libavcodec/libgsm.c | static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
{
AMRContext *s = avctx->priv_data;
if (avctx->sample_rate != 8000) {
av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
return AVERROR(ENOSYS);
}
if (avctx->channels != 1) {
av_log(avctx, AV_LOG_ERROR, "Only mono s... | [
1,
0
] |
FFmpeg | libavcodec/tiff.c | static int add_metadata(int count, int type,
const char *name, const char *sep, TiffContext *s)
{
switch (type) {
case TIFF_DOUBLE:
return add_doubles_metadata(count, name, sep, s);
case TIFF_SHORT:
return add_shorts_metadata(count, name, sep, s);
case TIFF_STRING:
retu... | [
1,
0
] |
qemu | tests/test-thread-pool.c | static void test_submit(void)
{
WorkerTestData data = {.n = 0};
thread_pool_submit(pool, worker_cb, &data);
qemu_aio_wait_all();
g_assert_cmpint(data.n, ==, 1);
} | [
1,
0
] |
qemu | hw/block/fdc.c | static void vfio_calxeda_xgmac_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
VFIOCalxedaXgmacDeviceClass *vcxc =
VFIO_CALXEDA_XGMAC_DEVICE_CLASS(klass);
vcxc->parent_realize = dc->realize;
dc->realize = calxeda_xgmac_realize;
dc->desc = "VFIO Calxeda XGMAC";
... | [
1,
0
] |
qemu | target-ppc/cpu.h | PPC_OP(slw)
{
if (T1 & 0x20) {
T0 = 0;
} else {
T0 = T0 << T1;
}
RETURN();
} | [
1,
0
] |
FFmpeg | postproc/rgb2rgb.c | void rgb16tobgr15(const uint8_t *src, uint8_t *dst, unsigned int src_size)
{
unsigned i;
unsigned num_pixels = src_size >> 1;
for (i = 0; i < num_pixels; i++)
{
unsigned b, g, r;
register uint16_t rgb;
rgb = src[2 * i];
r = rgb & 0x1F;
g = (rgb & 0x7E0) >> 5;
b = (rgb & 0xF800... | [
1,
0
] |
qemu | block/iscsi.c | static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun,
int evpd, int pc, void **inq,
Error **errp)
{
int full_size;
struct scsi_task *task = NULL;
task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64);
... | [
1,
0
] |
FFmpeg | libavformat/rmdec.c | static int get_num(ByteIOContext *pb, int *len)
{
int n, n1;
n = get_be16(pb);
(*len) -= 2;
// n &= 0x7FFF;
if (n >= 0x4000) {
return n - 0x4000;
} else {
n1 = get_be16(pb);
(*len) -= 2;
return (n << 16) | n1;
}
} | [
1,
0
] |
qemu | linux-user/main.c | static void gen_tlbsx_40x(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
TCGv t0;
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
t0 = tcg_temp_new();
gen_addr_reg_index(ctx, t0);
gen_helper_4... | [
1,
0
] |
FFmpeg | libavformat/rtpdec_h264.c | static int sdp_parse_fmtp_config_h264(AVFormatContext *s,
AVStream *stream,
PayloadContext *h264_data,
const char *attr, const char *value)
{
AVCodecParameters *par = stream->codecpar;
if (!strcmp... | [
1,
0
] |
qemu | Makefile.target | int select_watchdog(const char *p)
{
WatchdogTimerModel *model;
if (watchdog) {
fprintf(stderr,
"qemu: only one watchdog option may be given\n");
return 1;
}
/* -watchdog ? lists available devices and exits cleanly. */
if (strcmp(p, "?") == 0) {
LIST_FOREACH(model, &watchdog_l... | [
1,
0
] |
qemu | arch_init.c | static void smbios_build_type_1_fields(const char *t)
{
char buf[1024];
if (get_param_value(buf, sizeof(buf), "manufacturer", t))
smbios_add_field(1, offsetof(struct smbios_type_1, manufacturer_str),
strlen(buf) + 1, buf);
if (get_param_value(buf, sizeof(buf), "product", t))
sm... | [
1,
0
] |
qemu | target-alpha/helper.h | void helper_ldq_kernel(uint64_t t0, uint64_t t1)
{
ldq_kernel(t1, t0);
} | [
0,
0
] |
qemu | HACKING | static void mpc8544_guts_write(void *opaque, target_phys_addr_t addr,
uint64_t value, unsigned size)
{
addr &= MPC8544_GUTS_MMIO_SIZE - 1;
switch (addr) {
case MPC8544_GUTS_ADDR_RSTCR:
if (value & MPC8544_GUTS_RSTCR_RESET) {
qemu_system_reset_request();
}
b... | [
0,
0
] |
qemu | hw/ppc/spapr_drc.c | static uint32_t rtas_set_dr_indicator(uint32_t idx, uint32_t state)
{
sPAPRDRConnector *drc = spapr_drc_by_index(idx);
if (!drc) {
return RTAS_OUT_PARAM_ERROR;
}
trace_spapr_drc_set_dr_indicator(idx, state);
drc->dr_indicator = state;
return RTAS_OUT_SUCCESS;
} | [
0,
0
] |
qemu | block/nbd.c | SocketAddressLegacy *socket_local_address(int fd, Error **errp)
{
struct sockaddr_storage ss;
socklen_t sslen = sizeof(ss);
if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0) {
error_setg_errno(errp, errno, "%s",
"Unable to query local socket address");
return NULL;
}
... | [
1,
0
] |
qemu | HACKING | FWCfgState *fw_cfg_init(uint32_t ctl_port, uint32_t data_port,
target_phys_addr_t ctl_addr,
target_phys_addr_t data_addr)
{
DeviceState *dev;
SysBusDevice *d;
FWCfgState *s;
dev = qdev_create(NULL, "fw_cfg");
qdev_prop_set_uint32(dev, "ctl_iobase", ctl_po... | [
0,
0
] |
qemu | configure | static void boston_flash_write(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{} | [
1,
0
] |
FFmpeg | libavcodec/h264addpx_template.c | static void FUNCC(ff_h264_add_pixels8)(uint8_t *_dst, int16_t *_src, int stride)
{
int i;
pixel *dst = (pixel *)_dst;
dctcoef *src = (dctcoef *)_src;
stride /= sizeof(pixel);
for (i = 0; i < 8; i++) {
dst[0] += src[0];
dst[1] += src[1];
dst[2] += src[2];
dst[3] += src[3];
dst[4]... | [
1,
0
] |
qemu | hw/arm/armv7m.c | static void old_pc_system_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw)
{
char *filename;
MemoryRegion *bios, *isa_bios;
int bios_size, isa_bios_size;
int ret;
/* BIOS load */
if (bios_name == NULL) {
bios_name = BIOS_FILENAME;
}
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_n... | [
1,
0
] |
FFmpeg | libswscale/swscale_template.c | static inline void RENAME(bgr32ToY)(uint8_t *dst, uint8_t *src, int width)
{
int i;
for (i = 0; i < width; i++)
{
int b = ((uint32_t *)src)[i] & 0xFF;
int g = (((uint32_t *)src)[i] >> 8) & 0xFF;
int r = (((uint32_t *)src)[i] >> 16) & 0xFF;
dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2... | [
1,
0
] |
qemu | target/ppc/cpu.c | static void gen_read_xer(TCGv dst)
{
TCGv t0 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
TCGv t2 = tcg_temp_new();
tcg_gen_mov_tl(dst, cpu_xer);
tcg_gen_shli_tl(t0, cpu_so, XER_SO);
tcg_gen_shli_tl(t1, cpu_ov, XER_OV);
tcg_gen_shli_tl(t2, cpu_ca, XER_CA);
tcg_gen_or_tl(t0, t0, t1);
tcg_gen_o... | [
1,
0
] |
qemu | block.c | static int check_for_block_signature(BlockDriverState *bs, const uint8_t *buf)
{
static const uint8_t signatures[][4] = {
{'Q', 'F', 'I', 0xfb}, /* qcow/qcow2 */
{'C', 'O', 'W', 'D'}, /* VMDK3 */
{'V', 'M', 'D', 'K'}, /* VMDK4 */
{'O', 'O', 'O', 'M'}, /* UML COW */
{}
};
int... | [
1,
0
] |
qemu | hw/char/parallel.c | type_init(parallel_register_types)
static bool parallel_init(ISABus *bus, int index, CharDriverState *chr)
{
DeviceState *dev;
ISADevice *isadev;
isadev = isa_try_create(bus, "isa-parallel");
if (!isadev) {
return false;
}
dev = DEVICE(isadev);
qdev_prop_set_uint32(dev, "index", index);
... | [
1,
0
] |
FFmpeg | libavformat/asfdec.c | static int asf_read_metadata_obj(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
uint64_t size = avio_rl64(pb);
uint16_t nb_recs =
avio_rl16(pb); // number of records in the Description Records list
int i, ret;
for (i = 0; i < nb_recs; i++... | [
1,
0
] |
qemu | block-migration.c | static int qemu_rbd_snap_list(BlockDriverState *bs,
QEMUSnapshotInfo **psn_tab)
{
BDRVRBDState *s = bs->opaque;
QEMUSnapshotInfo *sn_info, *sn_tab = NULL;
int i, snap_count;
rbd_snap_info_t *snaps;
int max_snaps = RBD_MAX_SNAPS;
do {
snaps = g_malloc(sizeof(*snaps)... | [
1,
0
] |
qemu | fpu/softfloat.c | uint32 float32_to_uint32(float32 a STATUS_PARAM)
{
int64_t v;
uint32 res;
v = float32_to_int64(a STATUS_VAR);
if (v < 0) {
res = 0;
float_raise(float_flag_invalid STATUS_VAR);
} else if (v > 0xffffffff) {
res = 0xffffffff;
float_raise(float_flag_invalid STATUS_VAR);
} else {
... | [
1,
0
] |
qemu | target-arm/translate.c | static void gen_addq_lo(DisasContext *s, TCGv_i64 val, int rlow)
{
TCGv_i64 tmp;
TCGv tmp2;
/* Load value and extend to 64 bits. */
tmp = tcg_temp_new_i64();
tmp2 = load_reg(s, rlow);
tcg_gen_extu_i32_i64(tmp, tmp2);
dead_tmp(tmp2);
tcg_gen_add_i64(val, val, tmp);
tcg_temp_free_i64(tmp);
} | [
1,
0
] |
qemu | target-i386/cpu-qom.h | static bool hyperv_enabled(X86CPU *cpu)
{
CPUState *cs = CPU(cpu);
return kvm_check_extension(cs->kvm_state, KVM_CAP_HYPERV) > 0 &&
(hyperv_hypercall_available(cpu) ||
cpu->hyperv_time ||
cpu->hyperv_relaxed_timing);
} | [
1,
0
] |
qemu | hw/apb_pci.c | DeviceState *i2c_create_slave(i2c_bus *bus, const char *name, uint8_t addr)
{
DeviceState *dev;
dev = qdev_create(&bus->qbus, name);
qdev_prop_set_uint8(dev, "address", addr);
qdev_init(dev);
return dev;
} | [
1,
0
] |
qemu | block.c | static void nfs_co_generic_bh_cb(void *opaque)
{
NFSRPC *task = opaque;
task->complete = 1;
qemu_bh_delete(task->bh);
qemu_coroutine_enter(task->co, NULL);
} | [
1,
0
] |
qemu | include/exec/memory.h | static void access_with_adjusted_size(hwaddr addr,
uint64_t *value,
unsigned size,
unsigned access_size_min,
unsigned access_size_max,
... | [
1,
1
] |
qemu | blockdev.c | static void drive_uninit(DriveInfo *dinfo)
{
qemu_opts_del(dinfo->opts);
bdrv_delete(dinfo->bdrv);
QTAILQ_REMOVE(&drives, dinfo, next);
qemu_free(dinfo);
} | [
1,
0
] |
FFmpeg | libswscale/swscale_internal.h | static inline void
RENAME(yuv2rgb555_2)(SwsContext *c, const uint16_t *buf0,
const uint16_t *buf1, const uint16_t *ubuf0,
const uint16_t *ubuf1, const uint16_t *vbuf0,
const uint16_t *vbuf1, const uint16_t *abuf0,
const uint16_t *ab... | [
1,
0
] |
FFmpeg | libavformat/sapenc.c | static int sap_write_close(AVFormatContext *s)
{
struct SAPState *sap = s->priv_data;
int i;
for (i = 0; i < s->nb_streams; i++) {
AVFormatContext *rtpctx = s->streams[i]->priv_data;
if (!rtpctx)
continue;
av_write_trailer(rtpctx);
url_fclose(rtpctx->pb);
av_metadata_free(&rtpc... | [
1,
0
] |
qemu | block.c | static void do_order_test(void)
{
Coroutine *co;
co = qemu_coroutine_create(co_order_test);
record_push(1, 1);
qemu_coroutine_enter(co, NULL);
record_push(1, 2);
g_assert(!qemu_in_coroutine());
qemu_coroutine_enter(co, NULL);
record_push(1, 3);
g_assert(!qemu_in_coroutine());
} | [
1,
0
] |
FFmpeg | libavcodec/aacdec.c | static int latm_decode_audio_specific_config(struct LATMContext *latmctx,
GetBitContext *gb, int asclen)
{
AACContext *ac = &latmctx->aac_ctx;
AVCodecContext *avctx = ac->avctx;
MPEG4AudioConfig m4ac = {0};
int config_start_bit = get_bits_count(gb);
int sync... | [
1,
0
] |
qemu | hw/musicpal.c | static void do_sendkey(const char *string)
{
uint8_t keycodes[16];
int nb_keycodes = 0;
char keyname_buf[16];
char *separator;
int keyname_len, keycode, i;
while (1) {
separator = strchr(string, '-');
keyname_len = separator ? separator - string : strlen(string);
if (keyname_len > 0) {... | [
1,
0
] |
qemu | hw/nvram/mac_nvram.c | void pmac_format_nvram_partition(MacIONVRAMState *nvr, int len)
{
unsigned int i;
uint32_t start = 0, end;
struct OpenBIOS_nvpart_v1 *part_header;
// OpenBIOS nvram variables
// Variable partition
part_header = (struct OpenBIOS_nvpart_v1 *)nvr->data;
part_header->signature = OPENBIOS_PART_SYSTEM;
... | [
1,
1
] |
FFmpeg | libavcodec/mips/h264qpel_msa.c | void ff_put_h264_qpel4_mc02_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_vt_4w_msa(src - (stride * 2), stride, dst, stride, 4);
} | [
0,
0
] |
qemu | memory.c | void mtree_info(fprintf_function mon_printf, void *f)
{
MemoryRegionListHead ml_head;
MemoryRegionList *ml, *ml2;
QTAILQ_INIT(&ml_head);
mon_printf(f, "memory\n");
mtree_print_mr(mon_printf, f, address_space_memory.root, 0, 0, &ml_head);
/* print aliased regions */
QTAILQ_FOREACH(ml, &ml_head, que... | [
1,
0
] |
FFmpeg | libavcodec/truemotion2.c | static int tm2_read_deltas(TM2Context *ctx, int stream_id)
{
int d, mb;
int i, v;
d = get_bits(&ctx->gb, 9);
mb = get_bits(&ctx->gb, 5);
av_assert2(mb < 32);
if ((d < 1) || (d > TM2_DELTAS) || (mb < 1)) {
av_log(ctx->avctx, AV_LOG_ERROR,
"Incorrect delta table: %i deltas x %i bits\n",... | [
1,
0
] |
FFmpeg | libavcodec/libshine.c | static int libshine_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr)
{
SHINEContext *s = avctx->priv_data;
MPADecodeHeader hdr;
unsigned char *data;
long written;
int ret, len;
if (frame)
data = shine_encode_buffer(... | [
1,
0
] |
qemu | exec.c | void qemu_system_reset(void)
{
QEMUResetEntry *re, *nre;
/* reset all devices */
QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) { re->func(re->opaque); }
} | [
1,
0
] |
FFmpeg | libavcodec/Makefile | static int flac_write_trailer(struct AVFormatContext *s)
{
ByteIOContext *pb = s->pb;
uint8_t *streaminfo = s->streams[0]->codec->extradata;
int len = s->streams[0]->codec->extradata_size;
int64_t file_size;
if (streaminfo && len > 0 && !url_is_streamed(s->pb)) {
file_size = url_ftell(pb);
url... | [
1,
0
] |
qemu | ui/egl-helpers.c | int egl_rendernode_init(const char *rendernode)
{
qemu_egl_rn_fd = -1;
qemu_egl_rn_fd = qemu_egl_rendernode_open(rendernode);
if (qemu_egl_rn_fd == -1) {
error_report("egl: no drm render node available");
goto err;
}
qemu_egl_rn_gbm_dev = gbm_create_device(qemu_egl_rn_fd);
if (!qemu_egl_rn_g... | [
1,
0
] |
FFmpeg | libavformat/rtspdec.c | static inline int read_line(AVFormatContext *s, char *rbuf, const int rbufsize,
int *rbuflen)
{
RTSPState *rt = s->priv_data;
int idx = 0;
int ret = 0;
*rbuflen = 0;
do {
ret = ffurl_read_complete(rt->rtsp_hd, rbuf + idx, 1);
if (ret < 0)
return ret;
if... | [
1,
0
] |
qemu | hw/i386/smbios.c | static void smbios_check_collision(int type, int entry)
{
if (type < ARRAY_SIZE(first_opt)) {
if (first_opt[type].seen) {
if (first_opt[type].headertype != entry) {
error_report("Can't mix file= and type= for same type");
loc_push_restore(&first_opt[type].loc);
error_report("T... | [
0,
0
] |
qemu | hw/musicpal.c | static void musicpal_lcd_init(DisplayState *ds, uint32_t base)
{
musicpal_lcd_state *s;
int iomemtype;
s = qemu_mallocz(sizeof(musicpal_lcd_state));
if (!s)
return;
s->base = base;
s->ds = ds;
iomemtype = cpu_register_io_memory(0, musicpal_lcd_readfn,
mus... | [
0,
0
] |
qemu | HACKING | static void mips_qemu_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
if ((addr & 0xffff) == 0 && val == 42)
qemu_system_reset_request();
else if ((addr & 0xffff) == 4 && val == 42)
qemu_system_shutdown_request();
} | [
0,
0
] |
qemu | block/nbd.c | SocketAddress *socket_remote_address(int fd, Error **errp)
{
struct sockaddr_storage ss;
socklen_t sslen = sizeof(ss);
if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) {
error_setg_errno(errp, errno, "%s",
"Unable to query remote socket address");
return NULL;
}
re... | [
1,
0
] |
FFmpeg | libavformat/mov.c | static int mov_read_wave(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams - 1];
if ((uint64_t)atom.size > (1 << 30))
return -1;
if (st->codec->codec_id == CODEC_ID_QDM2) {
// pass all frma atom to codec, needed at least for QDM2
av_free(st->codec... | [
1,
0
] |
qemu | cmd.c | fetchline(void)
{
char *p, *line = malloc(MAXREADLINESZ);
if (!line)
return NULL;
printf("%s", get_prompt());
fflush(stdout);
if (!fgets(line, MAXREADLINESZ, stdin)) {
free(line);
return NULL;
}
p = line + strlen(line);
if (p != line && p[-1] == '\n')
p[-1] = '\0';
return ... | [
1,
0
] |
qemu | target-i386/bpt_helper.c | bool check_hw_breakpoints(CPUX86State *env, bool force_dr6_update)
{
target_ulong dr6;
int reg;
bool hit_enabled = false;
dr6 = env->dr[6] & ~0xf;
for (reg = 0; reg < DR7_MAX_BP; reg++) {
bool bp_match = false;
bool wp_match = false;
switch (hw_breakpoint_type(env->dr[7], reg)) {
cas... | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.