project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
qemu | bc7c08a2c375acb7ae4d433054415588b176d34c | 0 | static void test_qemu_strtoull_correct(void)
{
const char *str = "12345 foo";
char f = 'X';
const char *endptr = &f;
uint64_t res = 999;
int err;
err = qemu_strtoull(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, 12345);
g_assert(endptr ==... | 16,317 |
qemu | 3f66f764ee25f10d3e1144ebc057a949421b7728 | 0 | static void test_visitor_in_enum(TestInputVisitorData *data,
const void *unused)
{
Error *err = NULL;
Visitor *v;
EnumOne i;
for (i = 0; EnumOne_lookup[i]; i++) {
EnumOne res = -1;
v = visitor_input_test_init(data, "%s", EnumOne_lookup[i]);
... | 16,320 |
qemu | ddca7f86ac022289840e0200fd4050b2b58e9176 | 0 | static void v9fs_lock(void *opaque)
{
int8_t status;
V9fsFlock *flock;
size_t offset = 7;
struct stat stbuf;
V9fsFidState *fidp;
int32_t fid, err = 0;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
flock = g_malloc(sizeof(*flock));
pdu_unmarshal(pdu, offset, "dbdqqds"... | 16,321 |
FFmpeg | 577393321c389ad2973bec6168a8045c94a9e099 | 0 | int ff_intrax8_decode_picture(IntraX8Context *const w, int dquant,
int quant_offset)
{
MpegEncContext *const s = w->s;
int mb_xy;
assert(s);
w->use_quant_matrix = get_bits1(&s->gb);
w->dquant = dquant;
w->quant = dquant >> 1;
w->qsum = quant_offset... | 16,322 |
qemu | 18da7f94cdce130f2a71387de4980ffa817181a1 | 0 | void commit_start(BlockDriverState *bs, BlockDriverState *base,
BlockDriverState *top, int64_t speed,
BlockdevOnError on_error, BlockDriverCompletionFunc *cb,
void *opaque, Error **errp)
{
CommitBlockJob *s;
BlockReopenQueue *reopen_queue = NULL;
... | 16,323 |
qemu | 2c62f08ddbf3fa80dc7202eb9a2ea60ae44e2cc5 | 0 | static void blizzard_screen_dump(void *opaque, const char *filename,
bool cswitch, Error **errp)
{
BlizzardState *s = (BlizzardState *) opaque;
DisplaySurface *surface = qemu_console_surface(s->con);
blizzard_update_display(opaque);
if (s && surface_data(surface)... | 16,324 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void lan9118_writew(void *opaque, target_phys_addr_t offset,
uint32_t val)
{
lan9118_state *s = (lan9118_state *)opaque;
offset &= 0xff;
if (s->write_word_prev_offset != (offset & ~0x3)) {
/* New offset, reset word counter */
s->write_word_n = 0;
... | 16,325 |
qemu | f090c9d4ad5812fb92843d6470a1111c15190c4c | 0 | int float32_eq( float32 a, float32 b STATUS_PARAM )
{
if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
|| ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
) {
if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
... | 16,326 |
qemu | e7d336959b7c01699702dcda4b54a822972d74a8 | 0 | int chsc_sei_nt2_get_event(void *res)
{
ChscSeiNt2Res *nt2_res = (ChscSeiNt2Res *)res;
PciCcdfAvail *accdf;
PciCcdfErr *eccdf;
int rc = 1;
SeiContainer *sei_cont;
S390pciState *s = S390_PCI_HOST_BRIDGE(
object_resolve_path(TYPE_S390_PCI_HOST_BRIDGE, NULL));
if (!s) {
... | 16,327 |
qemu | b39e3f34c9de7ead6a11a74aa2de78baf41d81a7 | 0 | static void icount_adjust_rt(void *opaque)
{
timer_mod(icount_rt_timer,
qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL_RT) + 1000);
icount_adjust();
}
| 16,328 |
qemu | f02ca5cbeaf86038834c1953247a1579d7921927 | 0 | static inline int tcg_target_const_match(tcg_target_long val,
const TCGArgConstraint *arg_ct)
{
int ct;
ct = arg_ct->ct;
if (ct & TCG_CT_CONST)
return 1;
else if ((ct & TCG_CT_CONST_S11) && ABS(val) == (ABS(val) & 0x3ff))
return 1;
... | 16,329 |
qemu | e1123a3b40a1a9a625a29c8ed4debb7e206ea690 | 0 | static void iscsi_close(BlockDriverState *bs)
{
IscsiLun *iscsilun = bs->opaque;
struct iscsi_context *iscsi = iscsilun->iscsi;
iscsi_detach_aio_context(bs);
if (iscsi_is_logged_in(iscsi)) {
iscsi_logout_sync(iscsi);
}
iscsi_destroy_context(iscsi);
g_free(iscsilun->zeroblo... | 16,330 |
qemu | 10c4c98ab7dc18169b37b76f6ea5e60ebe65222b | 0 | void i2c_register_slave(I2CSlaveInfo *info)
{
assert(info->qdev.size >= sizeof(i2c_slave));
info->qdev.init = i2c_slave_qdev_init;
info->qdev.bus_type = BUS_TYPE_I2C;
qdev_register(&info->qdev);
}
| 16,331 |
qemu | 67a0fd2a9bca204d2b39f910a97c7137636a0715 | 0 | static int img_compare(int argc, char **argv)
{
const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
BlockBackend *blk1, *blk2;
BlockDriverState *bs1, *bs2;
int64_t total_sectors1, total_sectors2;
uint8_t *buf1 = NULL, *buf2 = NULL;
int pnum1, pnum2;
int allocated1,... | 16,332 |
FFmpeg | c04c3282b4334ff64cfd69d40fea010602e830fd | 0 | static int v4l2_read_header(AVFormatContext *s1, AVFormatParameters *ap)
{
struct video_data *s = s1->priv_data;
AVStream *st;
int width, height;
int res, frame_rate, frame_rate_base;
uint32_t desired_format, capabilities;
const char *video_device;
if (!ap || ap->width <= 0 || ap->... | 16,333 |
qemu | 85f94f868fcd868f0f605e9d3c1ad6351c557190 | 0 | static void handle_keyup(DisplayState *ds, SDL_Event *ev)
{
int mod_state;
if (!alt_grab) {
mod_state = (ev->key.keysym.mod & gui_grab_code);
} else {
mod_state = (ev->key.keysym.mod & (gui_grab_code | KMOD_LSHIFT));
}
if (!mod_state && gui_key_modifier_pressed) {
... | 16,334 |
FFmpeg | 1303d62d8416fa315a0cc7bbbe35cfdab787ea92 | 0 | static int mpegts_resync(ByteIOContext *pb)
{
int c, i;
for(i = 0;i < MAX_RESYNC_SIZE; i++) {
c = url_fgetc(pb);
if (c < 0)
return -1;
if (c == 0x47) {
url_fseek(pb, -1, SEEK_CUR);
return 0;
}
}
/* no sync found */
re... | 16,336 |
FFmpeg | 50833c9f7b4e1922197a8955669f8ab3589c8cef | 1 | static int write_header(FlashSV2Context * s, uint8_t * buf, int buf_size)
{
PutBitContext pb;
int buf_pos, len;
if (buf_size < 5)
return -1;
init_put_bits(&pb, buf, buf_size * 8);
put_bits(&pb, 4, (s->block_width >> 4) - 1);
put_bits(&pb, 12, s->image_width);
put_bits... | 16,337 |
qemu | 187337f8b0ec0813dd3876d1efe37d415fb81c2e | 1 | void usb_ohci_init_pxa(target_phys_addr_t base, int num_ports, int devfn,
qemu_irq irq)
{
OHCIState *ohci = (OHCIState *)qemu_mallocz(sizeof(OHCIState));
usb_ohci_init(ohci, num_ports, devfn, irq,
OHCI_TYPE_PXA, "OHCI USB");
ohci->mem_base = base;
cpu_... | 16,338 |
FFmpeg | 1bab6f852c7ca433285d19f65c701885fa69cc57 | 1 | static void RENAME(yuv2rgb32_1)(SwsContext *c, const int16_t *buf0,
const int16_t *ubuf[2], const int16_t *bguf[2],
const int16_t *abuf0, uint8_t *dest,
int dstW, int uvalpha, int y)
{
const int16_t *ubuf0 = ubuf[0]... | 16,340 |
qemu | 12848bfc5d719bad536c5448205a3226be1fda47 | 1 | VirtIODevice *virtio_9p_init(DeviceState *dev, V9fsConf *conf)
{
V9fsState *s;
int i, len;
struct stat stat;
FsTypeEntry *fse;
s = (V9fsState *)virtio_common_init("virtio-9p",
VIRTIO_ID_9P,
sizeof(struct virtio_9p_c... | 16,341 |
qemu | 88ee13c7b656e5504613b527f3a51591e9afae69 | 1 | int pcilg_service_call(S390CPU *cpu, uint8_t r1, uint8_t r2)
{
CPUS390XState *env = &cpu->env;
S390PCIBusDevice *pbdev;
uint64_t offset;
uint64_t data;
MemoryRegion *mr;
uint8_t len;
uint32_t fh;
uint8_t pcias;
cpu_synchronize_state(CPU(cpu));
if (env->psw.mask & P... | 16,342 |
qemu | 3e305e4a4752f70c0b5c3cf5b43ec957881714f7 | 1 | static void vnc_client_cache_auth(VncState *client)
{
if (!client->info) {
return;
}
#ifdef CONFIG_VNC_TLS
if (client->tls.session &&
client->tls.dname) {
client->info->has_x509_dname = true;
client->info->x509_dname = g_strdup(client->tls.dname);
}
#endif
#... | 16,343 |
FFmpeg | 9e27e0d4f825e97104333e3006f450f566935af0 | 1 | static void add_wav(int16_t *dest, int n, int skip_first, int *m,
const int16_t *s1, const int8_t *s2, const int8_t *s3)
{
int i;
int v[3];
v[0] = 0;
for (i=!skip_first; i<3; i++)
v[i] = (gain_val_tab[n][i] * m[i]) >> gain_exp_tab[n];
dest[i] = (s1[i]*v[... | 16,344 |
qemu | 039380a8e18f618cdacf72486449c04dc1b70eef | 1 | void qtest_qmp(QTestState *s, const char *fmt, ...)
{
va_list ap;
bool has_reply = false;
int nesting = 0;
/* Send QMP request */
va_start(ap, fmt);
socket_sendf(s->qmp_fd, fmt, ap);
va_end(ap);
/* Receive reply */
while (!has_reply || nesting > 0) {
ssize_t len;
char... | 16,345 |
qemu | aa4a3dce1c88ed51b616806b8214b7c8428b7470 | 1 | static void vmxnet3_reset(VMXNET3State *s)
{
VMW_CBPRN("Resetting vmxnet3...");
vmxnet3_deactivate_device(s);
vmxnet3_reset_interrupt_states(s);
vmxnet_tx_pkt_reset(s->tx_pkt);
s->drv_shmem = 0;
s->tx_sop = true;
s->skip_current_tx_pkt = false;
}
| 16,346 |
FFmpeg | eae7338e1592f4a398b7c3cb9d1ac854b7a44ff8 | 1 | static av_cold int X264_close(AVCodecContext *avctx)
{
X264Context *x4 = avctx->priv_data;
av_freep(&avctx->extradata);
av_free(x4->sei);
if (x4->enc)
x264_encoder_close(x4->enc);
av_frame_free(&avctx->coded_frame);
return 0;
}
| 16,347 |
qemu | c3e10c7b4377c1cbc0a4fbc12312c2cf41c0cda7 | 1 | static always_inline void gen_op_subfo_64 (void)
{
gen_op_move_T2_T0();
gen_op_subf();
gen_op_check_subfo_64();
}
| 16,349 |
qemu | d861b05ea30e6ac177de9b679da96194ebe21afc | 1 | int slirp_can_output(void)
{
return 1;
}
| 16,350 |
qemu | ec45bbe5f1921c6553fbf9c0c76b358b0403c22d | 1 | int main(int argc, char **argv, char **envp)
{
struct target_pt_regs regs1, *regs = ®s1;
struct image_info info1, *info = &info1;
struct linux_binprm bprm;
TaskState *ts;
CPUArchState *env;
CPUState *cpu;
int optind;
char **target_environ, **wrk;
char **target_argv;
... | 16,351 |
FFmpeg | 9c7fd997f794d3180ef4cbde019e4827ff309988 | 1 | static int aiff_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
int size, filesize;
offset_t offset = 0;
uint32_t tag;
unsigned version = AIFF_C_VERSION1;
ByteIOContext *pb = s->pb;
AVStream * st = s->streams[0];
/* check FORM header */
f... | 16,353 |
FFmpeg | f431315a866da9600e3eaa99fc54da1f554f170c | 1 | static int start_frame_overlay(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
{
AVFilterContext *ctx = inlink->dst;
OverlayContext *over = ctx->priv;
inlink->cur_buf = NULL;
over->overpicref = inpicref;
over->overpicref->pts = av_rescale_q(inpicref->pts, ctx->inputs[OVERLAY]->time_base... | 16,354 |
qemu | 8f94a6e40e46cbc8e8014da825d25824b1803b34 | 1 | int bdrv_file_open(BlockDriverState **pbs, const char *filename,
QDict *options, int flags, Error **errp)
{
BlockDriverState *bs;
BlockDriver *drv;
const char *drvname;
bool allow_protocol_prefix = false;
Error *local_err = NULL;
int ret;
/* NULL means an empty ... | 16,355 |
qemu | 6ab3fc32ea640026726bc5f9f4db622d0954fb8a | 1 | ser_write(void *opaque, hwaddr addr,
uint64_t val64, unsigned int size)
{
ETRAXSerial *s = opaque;
uint32_t value = val64;
unsigned char ch = val64;
D(qemu_log("%s " TARGET_FMT_plx "=%x\n", __func__, addr, value));
addr >>= 2;
switch (addr)
{
case RW_DOUT:
... | 16,356 |
FFmpeg | 066dc0437368acd21546ee327a0a94c60c3808b2 | 1 | static av_cold int X264_init(AVCodecContext *avctx)
{
X264Context *x4 = avctx->priv_data;
int sw,sh;
if (avctx->global_quality > 0)
av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
x264_param_default(&x4->params);
x4->params.b_deblocking_filter ... | 16,357 |
qemu | aebf81680bf49c5953d7ae9ebb7b98c0f4dad8f3 | 1 | int vhost_dev_init(struct vhost_dev *hdev, void *opaque,
VhostBackendType backend_type)
{
uint64_t features;
int i, r;
if (vhost_set_backend_type(hdev, backend_type) < 0) {
if (hdev->vhost_ops->vhost_backend_init(hdev, opaque) < 0) {
return -errno;
... | 16,359 |
qemu | 21ef45d71221b4577330fe3aacfb06afad91ad46 | 1 | static int vnc_display_disable_login(DisplayState *ds)
{
VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
if (!vs) {
return -1;
}
if (vs->password) {
g_free(vs->password);
}
vs->password = NULL;
if (vs->auth == VNC_AUTH_NONE) {
vs->auth =... | 16,362 |
qemu | 3df3e0a5872cbc8fcc55a0413416352eec68132e | 1 | static int vfio_connect_container(VFIOGroup *group)
{
VFIOContainer *container;
int ret, fd;
if (group->container) {
return 0;
}
QLIST_FOREACH(container, &container_list, next) {
if (!ioctl(group->fd, VFIO_GROUP_SET_CONTAINER, &container->fd)) {
group->contai... | 16,363 |
qemu | c572f23a3e7180dbeab5e86583e43ea2afed6271 | 1 | static void v9fs_fsync(void *opaque)
{
int err;
int32_t fid;
int datasync;
size_t offset = 7;
V9fsFidState *fidp;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
pdu_unmarshal(pdu, offset, "dd", &fid, &datasync);
fidp = get_fid(pdu, fid);
if (fidp == NULL) {
err = -ENOENT;
... | 16,364 |
FFmpeg | 4d986b71721ddf26ab8563b933ec8dd3ec88e59c | 1 | static float quantize_and_encode_band_cost(struct AACEncContext *s,
PutBitContext *pb, const float *in,
const float *scaled, int size, int scale_idx,
int cb, const float lambda, const float uplim,
... | 16,366 |
qemu | 7ccc44fd7d1dfa62c4d6f3a680df809d6e7068ce | 1 | static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options, char **export,
Error **errp)
{
SocketAddress *saddr;
if (qdict_haskey(options, "path") == qdict_haskey(options, "host")) {
if (qdict_haskey(options, "path")) {
error_setg(errp, "path an... | 16,367 |
qemu | faadf50e2962dd54175647a80bd6fc4319c91973 | 1 | 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;
... | 16,368 |
qemu | de82815db1c89da058b7fb941dab137d6d9ab738 | 1 | int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
BdrvCheckMode fix)
{
BDRVQcowState *s = bs->opaque;
int64_t size, i, highest_cluster, nb_clusters;
int refcount1, refcount2;
QCowSnapshot *sn;
uint16_t *refcount_table;
int ret;
size = ... | 16,369 |
qemu | 418661e0324c1c419552cf24bd4447292e884bdd | 1 | BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
const char *backing_file)
{
char *filename_full = NULL;
char *backing_file_full = NULL;
char *filename_tmp = NULL;
int is_protocol = 0;
BlockDriverState *curr_bs = NULL;
BlockDriverState *retval = NULL;
if (!... | 16,371 |
qemu | 1760048a5d21bacf0e4838da2f61b2d8db7d2866 | 1 | static void test_ivshmem_pair(void)
{
IVState state1, state2, *s1, *s2;
char *data;
int i;
setup_vm(&state1);
s1 = &state1;
setup_vm(&state2);
s2 = &state2;
data = g_malloc0(TMPSHMSIZE);
/* host write, guest 1 & 2 read */
memset(tmpshmem, 0x42, TMPSHMSIZE);
... | 16,372 |
FFmpeg | 43b434210e597d484aef57c4139c3126d22b7e2b | 1 | int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
{
AVCodecContext *const avctx = h->avctx;
H264SliceContext *sl;
int i;
av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
if (h->avctx->hwaccel ||
h->avctx->codec->capabilities... | 16,373 |
qemu | 5eb6a3c50185e101f87382f41fb66eed5784e7ac | 1 | static void qdev_prop_set_globals_for_type(DeviceState *dev,
const char *typename)
{
GList *l;
for (l = global_props; l; l = l->next) {
GlobalProperty *prop = l->data;
Error *err = NULL;
if (strcmp(typename, prop->driver) != 0) {
... | 16,374 |
FFmpeg | 98d0d19208959766a58f13dd6a678d1f765a26ac | 1 | static int lag_decode_frame(AVCodecContext *avctx,
void *data, int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
LagarithContext *l = avctx->priv_data;
AVFrame *const p = &l->picture;
uint8_t frametype = 0;
uint32... | 16,375 |
qemu | 36bcac16fdd6ecb75314db06171f54dcd400ab8c | 1 | static int sd_parse_uri(BDRVSheepdogState *s, const char *filename,
char *vdi, uint32_t *snapid, char *tag)
{
URI *uri;
QueryParams *qp = NULL;
int ret = 0;
uri = uri_parse(filename);
if (!uri) {
return -EINVAL;
}
/* transport */
if (!strcmp... | 16,376 |
qemu | 9b4e38fe6a35890bb1d995316d7be08de0b30ee5 | 1 | static void test_visitor_in_errors(TestInputVisitorData *data,
const void *unused)
{
TestStruct *p = NULL;
Error *err = NULL;
Visitor *v;
strList *q = NULL;
UserDefTwo *r = NULL;
WrapAlternate *s = NULL;
v = visitor_input_test_init(data, "{ 'integer': false... | 16,377 |
qemu | e92f0e1910f0655a0edd8d87c5a7262d36517a89 | 1 | BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
BlockCompletionFunc *cb, void *opaque)
{
trace_bdrv_aio_flush(bs, opaque);
Coroutine *co;
BlockAIOCBCoroutine *acb;
/* Matched by bdrv_co_complete's bdrv_dec_in_flight. */
bdrv_inc_in_flight(bs);
acb = qemu_aio_get(&bdrv_em_... | 16,378 |
FFmpeg | c4c3a3d580fa2f9d65af3fb6027ffbf9a28e9d55 | 1 | static int filter_packet(void *log_ctx, AVPacket *pkt,
AVFormatContext *fmt_ctx, AVBitStreamFilterContext *bsf_ctx)
{
AVCodecContext *enc_ctx = fmt_ctx->streams[pkt->stream_index]->codec;
int ret;
while (bsf_ctx) {
AVPacket new_pkt = *pkt;
ret = av_bitstream... | 16,379 |
qemu | a697a334b3c4d3250e6420f5d38550ea10eb5319 | 1 | VirtIODevice *virtio_net_init(DeviceState *dev, NICConf *conf,
virtio_net_conf *net)
{
VirtIONet *n;
n = (VirtIONet *)virtio_common_init("virtio-net", VIRTIO_ID_NET,
sizeof(struct virtio_net_config),
... | 16,380 |
qemu | 2c728dfef56d468a6a80b4dacdfb7109220d2546 | 1 | int cpu_x86_register(X86CPU *cpu, const char *cpu_model)
{
CPUX86State *env = &cpu->env;
x86_def_t def1, *def = &def1;
Error *error = NULL;
char *name, *features;
gchar **model_pieces;
memset(def, 0, sizeof(*def));
model_pieces = g_strsplit(cpu_model, ",", 2);
if (!model_pie... | 16,381 |
FFmpeg | eb36ee1ee11c269e24ad4595fadf50e78463d5e2 | 1 | static int srt_encode_frame(AVCodecContext *avctx,
unsigned char *buf, int bufsize, const AVSubtitle *sub)
{
SRTContext *s = avctx->priv_data;
ASSDialog *dialog;
int i, len, num;
s->ptr = s->buffer;
s->end = s->ptr + sizeof(s->buffer);
for (i=0; i<sub->num... | 16,382 |
qemu | c919297379e9980c2bcc4d2053addbc1fd6d762b | 1 | static int img_info(int argc, char **argv)
{
int c;
OutputFormat output_format = OFORMAT_HUMAN;
bool chain = false;
const char *filename, *fmt, *output;
ImageInfoList *list;
bool image_opts = false;
fmt = NULL;
output = NULL;
for(;;) {
int option_index = 0;
... | 16,383 |
FFmpeg | 590743101dc934043f34013f1c9bb9fb261355b0 | 1 | void pp_postprocess(const uint8_t * src[3], const int srcStride[3],
uint8_t * dst[3], const int dstStride[3],
int width, int height,
const QP_STORE_T *QP_store, int QPStride,
pp_mode *vm, void *vc, int pict_type)
{
int mbWi... | 16,384 |
qemu | 74b4c74d5efb0a489bdf0acc5b5d0197167e7649 | 0 | static int handle_sigp(S390CPU *cpu, uint8_t ipa1, uint32_t ipb)
{
CPUS390XState *env = &cpu->env;
const uint8_t r1 = ipa1 >> 4;
const uint8_t r3 = ipa1 & 0x0f;
int ret;
uint8_t order;
uint64_t *status_reg;
uint64_t param;
S390CPU *dst_cpu = NULL;
cpu_synchronize_state(CP... | 16,386 |
qemu | ef1e1e0782e99c9dcf2b35e5310cdd8ca9211374 | 0 | static void bt_hci_done(struct HCIInfo *info)
{
struct bt_hci_s *hci = hci_from_info(info);
int handle;
bt_device_done(&hci->device);
if (hci->device.lmp_name)
g_free((void *) hci->device.lmp_name);
/* Be gentle and send DISCONNECT to all connected peers and those
* curren... | 16,387 |
FFmpeg | 474d858fd9551b45a17e1f3a4322de1a88e749b9 | 0 | static int get_port(const struct sockaddr_storage *ss)
{
sockaddr_union ssu = (sockaddr_union){.storage = *ss};
if (ss->ss_family == AF_INET)
return ntohs(ssu.in.sin_port);
#if HAVE_STRUCT_SOCKADDR_IN6
if (ss->ss_family == AF_INET6)
return ntohs(ssu.in6.sin6_port);
#endif
return... | 16,388 |
FFmpeg | 631c56a8e46dea41585f3e7b3ef9c52b49faa385 | 0 | int avformat_network_deinit(void)
{
#if CONFIG_NETWORK
ff_network_close();
ff_tls_deinit();
ff_network_inited_globally = 0;
#endif
return 0;
}
| 16,389 |
FFmpeg | 72dbc610be3272ba36603f78a39cc2d2d8fe0cc3 | 0 | void ff_avg_h264_qpel8_mc02_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_vt_and_aver_dst_8x8_msa(src - (stride * 2), stride, dst, stride);
}
| 16,390 |
qemu | 6dd836f5d32b989e18c6dda655a26f4d73a52f6a | 0 | static void gen_spr_vtb(CPUPPCState *env)
{
spr_register(env, SPR_VTB, "VTB",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_tbl, SPR_NOACCESS,
0x00000000);
}
| 16,391 |
qemu | 991f8f0c91d65cebf51fa931450e02b0d5209012 | 0 | static void bswap_note(struct elf_note *en)
{
bswap32s(&en->n_namesz);
bswap32s(&en->n_descsz);
bswap32s(&en->n_type);
}
| 16,392 |
qemu | f8b6cc0070aab8b75bd082582c829be1353f395f | 0 | void ide_init_drive(IDEState *s, DriveInfo *dinfo,
const char *version, const char *serial)
{
int cylinders, heads, secs;
uint64_t nb_sectors;
s->bs = dinfo->bdrv;
bdrv_get_geometry(s->bs, &nb_sectors);
bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs);
s->cylin... | 16,393 |
qemu | 177b75104da3e3a9af84975c32a44782d903c41f | 0 | static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
{
BDRVDMGState *s = bs->opaque;
if (!is_sector_in_chunk(s, s->current_chunk, sector_num)) {
int ret;
uint32_t chunk = search_chunk(s, sector_num);
#ifdef CONFIG_BZIP2
uint64_t total_out;
#endif
... | 16,394 |
qemu | 56a6f02b8ce1fe41a2a9077593e46eca7d98267d | 0 | static void qmp_output_add_obj(QmpOutputVisitor *qov, const char *name,
QObject *value)
{
QStackEntry *e = QTAILQ_FIRST(&qov->stack);
QObject *cur = e ? e->value : NULL;
if (!cur) {
/* FIXME we should require the user to reset the visitor, rather
* th... | 16,395 |
qemu | 5666dd19dd95d966be00d0c3e7efdfaecc096ff3 | 0 | static GenericList *qapi_dealloc_next_list(Visitor *v, GenericList **list,
Error **errp)
{
GenericList *retval = *list;
g_free(retval->value);
*list = retval->next;
return retval;
}
| 16,397 |
qemu | fc19f8a02e45c4d8ad24dd7eb374330b03dfc28e | 0 | static int nbd_co_discard(BlockDriverState *bs, int64_t sector_num,
int nb_sectors)
{
BDRVNBDState *s = bs->opaque;
struct nbd_request request;
struct nbd_reply reply;
if (!(s->nbdflags & NBD_FLAG_SEND_TRIM)) {
return 0;
}
request.type = NBD_CMD_TRIM;... | 16,398 |
qemu | 897fa7cff21a98b260a5b3e73eae39273fa60272 | 0 | static bool memory_region_access_valid(MemoryRegion *mr,
target_phys_addr_t addr,
unsigned size)
{
if (!mr->ops->valid.unaligned && (addr & (size - 1))) {
return false;
}
/* Treat zero as compatibility all valid *... | 16,399 |
qemu | d7dccd11683d17e4658606349544312a0769ecea | 0 | static int pci_pcnet_init(PCIDevice *pci_dev)
{
PCIPCNetState *d = DO_UPCAST(PCIPCNetState, pci_dev, pci_dev);
PCNetState *s = &d->state;
uint8_t *pci_conf;
#if 0
printf("sizeof(RMD)=%d, sizeof(TMD)=%d\n",
sizeof(struct pcnet_RMD), sizeof(struct pcnet_TMD));
#endif
pci_conf = pc... | 16,400 |
FFmpeg | d6604b29ef544793479d7fb4e05ef6622bb3e534 | 0 | static int dvvideo_encode_close(AVCodecContext *avctx)
{
av_frame_free(&avctx->coded_frame);
return 0;
}
| 16,401 |
qemu | 920557971b60e53c2f3f22e5d6c620ab1ed411fd | 0 | void ich9_pm_init(PCIDevice *lpc_pci, ICH9LPCPMRegs *pm, bool smm_enabled,
qemu_irq sci_irq)
{
memory_region_init(&pm->io, OBJECT(lpc_pci), "ich9-pm", ICH9_PMIO_SIZE);
memory_region_set_enabled(&pm->io, false);
memory_region_add_subregion(pci_address_space_io(lpc_pci),
... | 16,402 |
qemu | 415fa2ea77b726ea5a5768d659881e919df1fcf2 | 0 | static inline int gen_intermediate_code_internal(CPUState *env,
TranslationBlock *tb,
int search_pc)
{
DisasContext dc1, *dc = &dc1;
uint8_t *pc_ptr;
uint16_t *gen_opc_end;
int flags, j, lj;
ui... | 16,403 |
qemu | f53a829bb9ef14be800556cbc02d8b20fc1050a7 | 0 | static void nbd_detach_aio_context(BlockDriverState *bs)
{
BDRVNBDState *s = bs->opaque;
nbd_client_session_detach_aio_context(&s->client);
}
| 16,404 |
qemu | 7ad4c7200111d20eb97eed4f46b6026e3f0b0eef | 0 | void *g_malloc0_n(size_t nmemb, size_t size)
{
size_t sz;
void *ptr;
__coverity_negative_sink__(nmemb);
__coverity_negative_sink__(size);
sz = nmemb * size;
ptr = __coverity_alloc__(size);
__coverity_writeall0__(ptr);
__coverity_mark_as_afm_allocated__(ptr, AFM_free);
ret... | 16,405 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint32_t nvram_readb (void *opaque, target_phys_addr_t addr)
{
M48t59State *NVRAM = opaque;
uint32_t retval;
retval = m48t59_read(NVRAM, addr);
return retval;
}
| 16,407 |
qemu | 9e85cd5ce0d3fc99d910428c9fd9d267764d341b | 0 | static void coroutine_fn commit_run(void *opaque)
{
CommitBlockJob *s = opaque;
BlockDriverState *active = s->active;
BlockDriverState *top = s->top;
BlockDriverState *base = s->base;
BlockDriverState *overlay_bs;
int64_t sector_num, end;
int ret = 0;
int n = 0;
void *buf;
... | 16,413 |
qemu | 720fdd6fa92df9041316e94816ab7e56abaed4e9 | 0 | static int nvme_start_ctrl(NvmeCtrl *n)
{
uint32_t page_bits = NVME_CC_MPS(n->bar.cc) + 12;
uint32_t page_size = 1 << page_bits;
if (n->cq[0] || n->sq[0] || !n->bar.asq || !n->bar.acq ||
n->bar.asq & (page_size - 1) || n->bar.acq & (page_size - 1) ||
NVME_CC_MPS(n->bar.cc) < ... | 16,416 |
qemu | e8dd1d9c396104f0fac4b39a701143df49df2a74 | 0 | static void netmap_send(void *opaque)
{
NetmapState *s = opaque;
struct netmap_ring *ring = s->me.rx;
/* Keep sending while there are available packets into the netmap
RX ring and the forwarding path towards the peer is open. */
while (!nm_ring_empty(ring) && qemu_can_send_packet(&s->nc))... | 16,417 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t gpio_read(void *opaque, target_phys_addr_t addr, unsigned size)
{
struct gpio_state_t *s = opaque;
uint32_t r = 0;
addr >>= 2;
switch (addr)
{
case R_PA_DIN:
r = s->regs[RW_PA_DOUT] & s->regs[RW_PA_OE];
/* Encode pins from the nand. */
... | 16,418 |
qemu | 93587e3af3a259deac89c12863d93653d69d22b8 | 0 | static void vfio_probe_igd_bar4_quirk(VFIOPCIDevice *vdev, int nr)
{
struct vfio_region_info *rom = NULL, *opregion = NULL,
*host = NULL, *lpc = NULL;
VFIOQuirk *quirk;
VFIOIGDQuirk *igd;
PCIDevice *lpc_bridge;
int i, ret, ggms_mb, gms_mb = 0, gen;
uint64_t *b... | 16,420 |
qemu | a9321a4d49d65d29c2926a51aedc5b91a01f3591 | 0 | int cpu_x86_handle_mmu_fault(CPUX86State *env, target_ulong addr,
int is_write1, int mmu_idx)
{
uint64_t ptep, pte;
target_ulong pde_addr, pte_addr;
int error_code, is_dirty, prot, page_size, is_write, is_user;
target_phys_addr_t paddr;
uint32_t page_offset;
... | 16,421 |
qemu | 910f738b851a263396fc85b2052e47f884ffead3 | 1 | static void test_qga_invalid_args(gconstpointer fix)
{
const TestFixture *fixture = fix;
QDict *ret, *error;
const gchar *class, *desc;
ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping', "
"'arguments': {'foo': 42 }}");
g_assert_nonnull(ret);
error = qdict_get_qdic... | 16,423 |
FFmpeg | 1abcd972c4c0e16f1e83be2fd32a251f51b2946d | 1 | int ff_mlz_decompression(MLZ* mlz, GetBitContext* gb, int size, unsigned char *buff) {
MLZDict *dict = mlz->dict;
unsigned long output_chars;
int string_code, last_string_code, char_code;
string_code = 0;
char_code = -1;
last_string_code = -1;
output_chars = 0;
while (outpu... | 16,424 |
qemu | a01672d3968cf91208666d371784110bfde9d4f8 | 1 | static void kvm_client_set_memory(struct CPUPhysMemoryClient *client,
target_phys_addr_t start_addr,
ram_addr_t size, ram_addr_t phys_offset,
bool log_dirty)
{
kvm_set_phys_mem(start_addr, size, phys_offset, l... | 16,426 |
qemu | 22644cd2c60151a964d9505f4c5f7baf845f20d8 | 1 | static void balloon_stats_set_poll_interval(Object *obj, struct Visitor *v,
void *opaque, const char *name,
Error **errp)
{
VirtIOBalloon *s = opaque;
Error *local_err = NULL;
int64_t value;
visit_type_int(v... | 16,428 |
FFmpeg | 6770a9d6898a0c7561586dabd7a4e5b5187bed62 | 1 | static OutputStream *choose_output(void)
{
int i;
int64_t opts_min = INT64_MAX;
OutputStream *ost_min = NULL;
for (i = 0; i < nb_output_streams; i++) {
OutputStream *ost = output_streams[i];
int64_t opts = av_rescale_q(ost->st->cur_dts, ost->st->time_base,
... | 16,429 |
qemu | 1108b2f8a939fb5778d384149e2f1b99062a72da | 1 | static int vfio_msi_setup(VFIOPCIDevice *vdev, int pos)
{
uint16_t ctrl;
bool msi_64bit, msi_maskbit;
int ret, entries;
if (pread(vdev->vbasedev.fd, &ctrl, sizeof(ctrl),
vdev->config_offset + pos + PCI_CAP_FLAGS) != sizeof(ctrl)) {
return -errno;
}
ctrl = le16_to... | 16,430 |
qemu | 2db59a76c421cdd1039d10e32a9798952d3ff5ba | 1 | static void gen_advance_ccount(DisasContext *dc)
{
gen_advance_ccount_cond(dc);
dc->ccount_delta = 0;
}
| 16,432 |
qemu | bc5008a832f95aae86efce844382e64d54da2146 | 1 | void init_paths(const char *prefix)
{
char pref_buf[PATH_MAX];
if (prefix[0] == '\0' ||
!strcmp(prefix, "/"))
return;
if (prefix[0] != '/') {
char *cwd = getcwd(NULL, 0);
size_t pref_buf_len = sizeof(pref_buf);
if (!cwd)
abort();
p... | 16,433 |
qemu | 5e003f17ec518cd96f5d2ac23ce9e14144426235 | 1 | int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn,
BlockDriverState *vm_state_bs,
uint64_t vm_state_size,
BlockDriverState **first_bad_bs)
{
int err = 0;
BlockDriverState *bs;
BdrvNextIterator it;
for (bs = ... | 16,434 |
qemu | ba026602a673677735428e64e621cdf95b5cd6d9 | 1 | void tb_target_set_jmp_target(uintptr_t tc_ptr, uintptr_t jmp_addr,
uintptr_t addr)
{
if (TCG_TARGET_REG_BITS == 64) {
tcg_insn_unit i1, i2;
intptr_t tb_diff = addr - tc_ptr;
intptr_t br_diff = addr - (jmp_addr + 4);
uint64_t pair;
/* T... | 16,436 |
FFmpeg | 8c50704ebf1777bee76772c4835d9760b3721057 | 1 | static av_always_inline int setup_classifs(vorbis_context *vc,
vorbis_residue *vr,
uint8_t *do_not_decode,
unsigned ch_used,
int partition_count... | 16,438 |
FFmpeg | 55188278169c3a1838334d7aa47a1f7a40741690 | 1 | static int xan_unpack(uint8_t *dest, const int dest_len,
const uint8_t *src, const int src_len)
{
uint8_t opcode;
int size;
uint8_t *orig_dest = dest;
const uint8_t *src_end = src + src_len;
const uint8_t *dest_end = dest + dest_len;
while (dest < dest_end) {
... | 16,439 |
qemu | 7266ae91a111001abda65c79299c9b7e365456b6 | 1 | static void qht_do_test(unsigned int mode, size_t init_entries)
{
qht_init(&ht, 0, mode);
insert(0, N);
check(0, N, true);
check_n(N);
check(-N, -1, false);
iter_check(N);
rm(101, 102);
check_n(N - 1);
insert(N, N * 2);
check_n(N + N - 1);
rm(N, N * 2);
check_n(N - 1);
... | 16,440 |
FFmpeg | 69dde1ad36b7d95b8b9268f414aa6c076212ed41 | 0 | static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack* track)
{
int64_t maxTrackLenTemp;
put_be32(pb, 0x5c); /* size (always 0x5c) */
put_tag(pb, "tkhd");
put_be32(pb, 0xf); /* version & flags (track enabled) */
put_be32(pb, track->time); /* creation time */
put_be32(pb, track->time);... | 16,441 |
FFmpeg | 01ecb7172b684f1c4b3e748f95c5a9a494ca36ec | 1 | static void quantize_and_encode_band_cost_NONE_mips(struct AACEncContext *s,
PutBitContext *pb, const float *in, float *out,
const float *scaled, int size, int scale_idx,
... | 16,442 |
qemu | 3a661f1eabf7e8db66e28489884d9b54aacb94ea | 1 | int qcrypto_cipher_setiv(QCryptoCipher *cipher,
const uint8_t *iv, size_t niv,
Error **errp)
{
QCryptoCipherNettle *ctx = cipher->opaque;
if (niv != ctx->niv) {
error_setg(errp, "Expected IV size %zu not %zu",
ctx->niv, niv);
... | 16,443 |
qemu | e2f89926f19d2940eda070542501f39f51a8c81f | 1 | static int uhci_handle_td(UHCIState *s, uint32_t addr, UHCI_TD *td,
uint32_t *int_mask, bool queuing)
{
UHCIAsync *async;
int len = 0, max_len;
uint8_t pid;
USBDevice *dev;
USBEndpoint *ep;
/* Is active ? */
if (!(td->ctrl & TD_CTRL_ACTIVE))
retu... | 16,444 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.