project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
FFmpeg | 581898ae882dc37967b689b6ea5f2b2a9acd257a | 1 | static int ptx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt) {
const uint8_t *buf = avpkt->data;
const uint8_t *buf_end = avpkt->data + avpkt->size;
PTXContext * const s = avctx->priv_data;
AVFrame *picture = data;
AVFrame * const p = &s... | 16,181 |
qemu | 65f33bc0020112e7be7b8966495cd5efa2d0ab15 | 1 | static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size)
{
BDRVQcowState *s = bs->opaque;
uint64_t i, nb_clusters;
int refcount;
nb_clusters = size_to_clusters(s, size);
retry:
for(i = 0; i < nb_clusters; i++) {
uint64_t next_cluster_index = s->free_cluster_index++;... | 16,182 |
qemu | 637f7a6a01e09bc39f7b3a24257a9cd6ea396ca0 | 1 | static void vhost_region_del(MemoryListener *listener,
MemoryRegionSection *section)
{
struct vhost_dev *dev = container_of(listener, struct vhost_dev,
memory_listener);
int i;
vhost_set_memory(listener, section, false);
for ... | 16,186 |
FFmpeg | e7a6d5f313101bb1403fda2889d1942b4ddaeea3 | 1 | static int wma_decode_block(WMADecodeContext *s)
{
int n, v, a, ch, code, bsize;
int coef_nb_bits, total_gain, parse_exponents;
DECLARE_ALIGNED_16(float, window[BLOCK_MAX_SIZE * 2]);
int nb_coefs[MAX_CHANNELS];
float mdct_norm;
#ifdef TRACE
tprintf("***decode_block: %d:%d\n", s->frame_... | 16,187 |
FFmpeg | b7e506b3b9caf1d7b8b494f83a85c1b61be46993 | 1 | static int swf_probe(AVProbeData *p)
{
if(p->buf_size < 15)
return 0;
/* check file header */
if ( AV_RB24(p->buf) != AV_RB24("CWS")
&& AV_RB24(p->buf) != AV_RB24("FWS"))
return 0;
if (p->buf[3] >= 20)
return AVPROBE_SCORE_MAX / 4;
return AVPROBE_SCO... | 16,188 |
FFmpeg | 1bab6f852c7ca433285d19f65c701885fa69cc57 | 1 | static void RENAME(yuv2yuyv422_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 =... | 16,189 |
qemu | ba7806ad92a2f6b1625cfa67d44dc1b71e3be44e | 1 | void command_loop(void)
{
int c, i, j = 0, done = 0, fetchable = 0, prompted = 0;
char *input;
char **v;
const cmdinfo_t *ct;
for (i = 0; !done && i < ncmdline; i++) {
input = strdup(cmdline[i]);
if (!input) {
fprintf(stderr, _("cannot strdup command '%s': %s\n... | 16,191 |
qemu | 7d2aabe262846ddeda1785d42ff4d7964e8ac1c8 | 1 | static inline void gen_neon_mull(TCGv_i64 dest, TCGv a, TCGv b, int size, int u)
{
TCGv_i64 tmp;
switch ((size << 1) | u) {
case 0: gen_helper_neon_mull_s8(dest, a, b); break;
case 1: gen_helper_neon_mull_u8(dest, a, b); break;
case 2: gen_helper_neon_mull_s16(dest, a, b); break;
case 3... | 16,192 |
qemu | cf0f7cf903073f9dd9979dd33d52618b384ac2cb | 1 | static void dummy_signal(int sig)
{
}
| 16,193 |
qemu | e23a1b33b53d25510320b26d9f154e19c6c99725 | 1 | void mips_malta_init (ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
char *filename;
ram_addr_t ram_offset;
ram_addr_t bios_o... | 16,194 |
qemu | dc8714ca57c1796abddf7c96d6f66852a972cb08 | 1 | void HELPER(set_cp15)(CPUState *env, uint32_t insn, uint32_t val)
{
int op1;
int op2;
int crm;
op1 = (insn >> 21) & 7;
op2 = (insn >> 5) & 7;
crm = insn & 0xf;
switch ((insn >> 16) & 0xf) {
case 0:
/* ID codes. */
if (arm_feature(env, ARM_FEATURE_XSCALE))
... | 16,195 |
qemu | ac7e4cbbabae5a8e0d3948ddebf33351e61497c3 | 1 | S390CPU *s390x_new_cpu(const char *typename, uint32_t core_id, Error **errp)
{
S390CPU *cpu = S390_CPU(object_new(typename));
Error *err = NULL;
object_property_set_int(OBJECT(cpu), core_id, "core-id", &err);
if (err != NULL) {
goto out;
}
object_property_set_bool(OBJECT(cpu), ... | 16,196 |
qemu | e7b921c2d9efc249f99b9feb0e7dca82c96aa5c4 | 1 | static inline bool regime_is_user(CPUARMState *env, ARMMMUIdx mmu_idx)
{
switch (mmu_idx) {
case ARMMMUIdx_S1SE0:
case ARMMMUIdx_S1NSE0:
return true;
default:
return false;
case ARMMMUIdx_S12NSE0:
case ARMMMUIdx_S12NSE1:
g_assert_not_reached();
}
} | 16,198 |
FFmpeg | f77571f6bb5a252e09fc47049b0c61cc11559fad | 1 | int ff_fill_line_with_color(uint8_t *line[4], int pixel_step[4], int w, uint8_t dst_color[4],
enum AVPixelFormat pix_fmt, uint8_t rgba_color[4],
int *is_packed_rgba, uint8_t rgba_map_ptr[4])
{
uint8_t rgba_map[4] = {0};
int i;
const AVPixFmtDescr... | 16,199 |
FFmpeg | 65cd45a88c4a657b4ae0c81b753bb0d065a4e25a | 1 | static int bfi_decode_frame(AVCodecContext * avctx, void *data,
int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
BFIContext *bfi = avctx->priv_data;
uint8_t *dst = bfi->dst;
uint8_t *src, *dst_offset, colour1, colour2... | 16,200 |
qemu | e4f4fb1eca795e36f363b4647724221e774523c1 | 1 | static void sysbus_device_class_init(ObjectClass *klass, void *data)
{
DeviceClass *k = DEVICE_CLASS(klass);
k->init = sysbus_device_init;
k->bus_type = TYPE_SYSTEM_BUS;
} | 16,201 |
FFmpeg | bd10f6e1492492b0dfddc7dd8773e782ccea6daf | 1 | static av_cold int g726_init(AVCodecContext * avctx)
{
G726Context* c = avctx->priv_data;
unsigned int index= (avctx->bit_rate + avctx->sample_rate/2) / avctx->sample_rate - 2;
if (avctx->bit_rate % avctx->sample_rate && avctx->codec->encode) {
av_log(avctx, AV_LOG_ERROR, "Bitrate - Samplerat... | 16,202 |
FFmpeg | 8136f234445862c94d1c081606b2d1e3d44fccf3 | 1 | static int yop_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt)
{
YopDecContext *s = avctx->priv_data;
int tag, firstcolor, is_odd_frame;
int ret, i, x, y;
uint32_t *palette;
if (s->frame.data[0])
avctx->release_buffer(avc... | 16,206 |
qemu | 575750581c6ea70e89a7889cb6028f234f9d2ee9 | 1 | static int32_t scsi_send_command(SCSIDevice *d, uint32_t tag,
uint8_t *buf, int lun)
{
SCSIDeviceState *s = d->state;
uint64_t nb_sectors;
uint32_t lba;
uint32_t len;
int cmdlen;
int is_write;
uint8_t command;
uint8_t *outbuf;
SCSIRequest *... | 16,208 |
qemu | c001ed15f7bfeaa3cabde5c9cc79c4dfdb674769 | 1 | void cpu_dump_state (CPUCRISState *env, FILE *f, fprintf_function cpu_fprintf,
int flags)
{
int i;
uint32_t srs;
if (!env || !f)
return;
cpu_fprintf(f, "PC=%x CCS=%x btaken=%d btarget=%x\n"
"cc_op=%d cc_src=%d cc_dest=%d cc_result=%x cc_mask=%x\n",
env->pc, env->pregs... | 16,209 |
FFmpeg | eafa1c90e573c14562987390d1001d4e636d5a74 | 1 | void ff_snow_horizontal_compose97i_sse2(IDWTELEM *b, int width){
const int w2= (width+1)>>1;
// SSE2 code runs faster with pointers aligned on a 32-byte boundary.
IDWTELEM temp_buf[(width>>1) + 4];
IDWTELEM * const temp = temp_buf + 4 - (((int)temp_buf & 0xF) >> 2);
const int w_l= (width>>1);
... | 16,210 |
FFmpeg | 5e715b583dab85735660b15a8d217a69164675fe | 1 | static int parse_meter(DBEContext *s)
{
if (s->meter_size)
skip_input(s, s->key_present + s->meter_size + 1);
return 0;
}
| 16,212 |
qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 | 1 | static inline void gen_add_datah_offset(DisasContext *s, unsigned int insn,
int extra, TCGv var)
{
int val, rm;
TCGv offset;
if (insn & (1 << 22)) {
/* immediate */
val = (insn & 0xf) | ((insn >> 4) & 0xf0);
if (!(insn & (1 << 23)))
... | 16,213 |
qemu | ea375f9ab8c76686dca0af8cb4f87a4eb569cad3 | 1 | int kvm_cpu_exec(CPUState *env)
{
struct kvm_run *run = env->kvm_run;
int ret;
dprintf("kvm_cpu_exec()\n");
do {
#ifndef CONFIG_IOTHREAD
if (env->exit_request) {
dprintf("interrupt exit requested\n");
ret = 0;
break;
}
#endif
... | 16,215 |
qemu | e9db8ff38e539260a2cb5a7918d1155b7d92a264 | 1 | static struct glfs *qemu_gluster_init(BlockdevOptionsGluster *gconf,
const char *filename,
QDict *options, Error **errp)
{
int ret;
if (filename) {
ret = qemu_gluster_parse_uri(gconf, filename);
if (ret < 0) {
... | 16,217 |
qemu | 297a3646c2947ee64a6d42ca264039732c6218e0 | 1 | void visit_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp)
{
int64_t value;
if (!error_is_set(errp)) {
if (v->type_size) {
v->type_size(v, obj, name, errp);
} else if (v->type_uint64) {
v->type_uint64(v, obj, name, errp);
} else {
... | 16,218 |
FFmpeg | 2f96cc1fc41f2d3a349d55f9d2078694a6a87dc1 | 1 | int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
const char *method, const char *url,
const char *header,
RTSPMessageHeader *reply,
unsigned char **content_ptr,
... | 16,219 |
qemu | 7f0278435df1fa845b3bd9556942f89296d4246b | 1 | static void qmp_input_type_str(Visitor *v, char **obj, const char *name,
Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
QObject *qobj = qmp_input_get_object(qiv, name, true);
if (!qobj || qobject_type(qobj) != QTYPE_QSTRING) {
error_setg(errp, QERR_INVALID_P... | 16,220 |
FFmpeg | 892a4c2da8518aa5c86b6cfdd90a7f399a41c814 | 1 | int ff_huff_build_tree(AVCodecContext *avctx, VLC *vlc, int nb_codes,
Node *nodes, huff_cmp_t cmp, int hnode_first)
{
int i, j;
int cur_node;
int64_t sum = 0;
for(i = 0; i < nb_codes; i++){
nodes[i].sym = i;
nodes[i].n0 = -2;
sum += nodes[i].coun... | 16,221 |
FFmpeg | 05a4bacbf7ece618553d339afe1d0b57bc87aea8 | 0 | uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
int size)
{
int ret;
uint8_t *data;
if ((unsigned)size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
return NULL;
data = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (... | 16,222 |
qemu | 4083733db5e4120939acee57019ff52db1f45b9d | 0 | static void jazz_led_text_update(void *opaque, console_ch_t *chardata)
{
LedState *s = opaque;
char buf[2];
dpy_text_cursor(s->con, -1, -1);
qemu_console_resize(s->con, 2, 1);
/* TODO: draw the segments */
snprintf(buf, 2, "%02hhx\n", s->segments);
console_write_ch(chardata++, 0x... | 16,223 |
qemu | 32bafa8fdd098d52fbf1102d5a5e48d29398c0aa | 0 | static void tcp_chr_tls_init(CharDriverState *chr)
{
TCPCharDriver *s = chr->opaque;
QIOChannelTLS *tioc;
Error *err = NULL;
if (s->is_listen) {
tioc = qio_channel_tls_new_server(
s->ioc, s->tls_creds,
NULL, /* XXX Use an ACL */
&err);
} else {... | 16,224 |
FFmpeg | 78f680cb3664624fedc00d03b0cd77255da2776b | 0 | static int smacker_read_header(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
SmackerContext *smk = s->priv_data;
AVStream *st, *ast[7];
int i, ret;
int tbase;
/* read and check header */
smk->magic = avio_rl32(pb);
if (smk->magic != MKTAG('S', 'M', 'K', '2') && smk->magic != ... | 16,225 |
FFmpeg | e3fb74f7f9a8f1895381355f40c92cac3c1023d9 | 0 | static int init_output_stream(OutputStream *ost, char *error, int error_len)
{
int ret = 0;
if (ost->encoding_needed) {
AVCodec *codec = ost->enc;
AVCodecContext *dec = NULL;
InputStream *ist;
ret = init_output_stream_encode(ost);
if (ret < 0)
... | 16,226 |
FFmpeg | 3019b4f6480a5d8c38e0e32ef75dabe6e0f3ae98 | 0 | static inline CopyRet receive_frame(AVCodecContext *avctx,
void *data, int *got_frame)
{
BC_STATUS ret;
BC_DTS_PROC_OUT output = {
.PicInfo.width = avctx->width,
.PicInfo.height = avctx->height,
};
CHDContext *priv = avctx->priv_data;
HAN... | 16,228 |
qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 | 0 | void omap_mpuio_out_set(struct omap_mpuio_s *s, int line, qemu_irq handler)
{
if (line >= 16 || line < 0)
hw_error("%s: No GPIO line %i\n", __FUNCTION__, line);
s->handler[line] = handler;
}
| 16,229 |
qemu | 4f213879f3cc695644cfd8bf603495e7316c78f6 | 0 | int pic_read_irq(DeviceState *d)
{
PICCommonState *s = DO_UPCAST(PICCommonState, dev.qdev, d);
int irq, irq2, intno;
irq = pic_get_irq(s);
if (irq >= 0) {
if (irq == 2) {
irq2 = pic_get_irq(slave_pic);
if (irq2 >= 0) {
pic_intack(slave_pic, irq2... | 16,230 |
qemu | e1833e1f96456fd8fc17463246fe0b2050e68efb | 0 | static inline void gen_bcond (DisasContext *ctx, int type)
{
target_ulong target = 0;
target_ulong li;
uint32_t bo = BO(ctx->opcode);
uint32_t bi = BI(ctx->opcode);
uint32_t mask;
if ((bo & 0x4) == 0)
gen_op_dec_ctr();
switch(type) {
case BCOND_IM:
li = (targ... | 16,231 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 0 | DriveInfo *drive_get_by_id(const char *id)
{
DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) {
if (strcmp(id, dinfo->id))
continue;
return dinfo;
}
return NULL;
}
| 16,232 |
qemu | dc7588c1eb3008bda53dde1d6b890cd299758155 | 0 | static BlockDriverAIOCB *rbd_start_aio(BlockDriverState *bs,
int64_t sector_num,
QEMUIOVector *qiov,
int nb_sectors,
BlockDriverCompletionFunc *cb,
... | 16,233 |
qemu | 6efeb3286dd80c8c943f50fbb5f611d525cd6f8a | 0 | static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
{
int ret;
trace_colo_compare_main("compare udp");
ret = colo_packet_compare_common(ppkt, spkt);
if (ret) {
trace_colo_compare_udp_miscompare("primary pkt size", ppkt->size);
qemu_hexdump((char *)ppkt->data, stde... | 16,234 |
qemu | adc370a48fd26b92188fa4848dfb088578b1936c | 0 | void helper_msa_st_df(CPUMIPSState *env, uint32_t df, uint32_t wd, uint32_t rs,
int32_t s10)
{
wr_t *pwd = &(env->active_fpu.fpr[wd].wr);
target_ulong addr = env->active_tc.gpr[rs] + (s10 << df);
int i;
switch (df) {
case DF_BYTE:
for (i = 0; i < DF_ELEMENTS(DF... | 16,236 |
qemu | 46232aaacb66733d3e16dcbd0d26c32ec388801d | 0 | static void apic_common_class_init(ObjectClass *klass, void *data)
{
ICCDeviceClass *idc = ICC_DEVICE_CLASS(klass);
DeviceClass *dc = DEVICE_CLASS(klass);
dc->vmsd = &vmstate_apic_common;
dc->reset = apic_reset_common;
dc->props = apic_properties_common;
idc->realize = apic_common_reali... | 16,238 |
FFmpeg | 1ec83d9a9e472f485897ac92bad9631d551a8c5b | 0 | static unsigned tget_short(const uint8_t **p, int le)
{
unsigned v = le ? AV_RL16(*p) : AV_RB16(*p);
*p += 2;
return v;
}
| 16,239 |
qemu | d516f74c99b1a2c289cfba0bacf125cbc9b681e3 | 0 | static void s390_cpu_initial_reset(CPUState *s)
{
S390CPU *cpu = S390_CPU(s);
CPUS390XState *env = &cpu->env;
int i;
s390_cpu_reset(s);
/* initial reset does not clear everything! */
memset(&env->start_initial_reset_fields, 0,
offsetof(CPUS390XState, end_reset_fields) -
... | 16,240 |
qemu | a3fa1d78cbae2259491b17689812edcb643a3b30 | 0 | static void migrate_fd_cancel(MigrationState *s)
{
if (s->state != MIG_STATE_ACTIVE)
return;
DPRINTF("cancelling migration\n");
s->state = MIG_STATE_CANCELLED;
notifier_list_notify(&migration_state_notifiers, s);
migrate_fd_cleanup(s);
}
| 16,241 |
qemu | 151c5693258f594541fa9ea585547a0a8dd68abc | 0 | static void test_dispatch_cmd(void)
{
QDict *req = qdict_new();
QObject *resp;
qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd")));
resp = qmp_dispatch(QOBJECT(req));
assert(resp != NULL);
assert(!qdict_haskey(qobject_to_qdict(resp), "error"));
g_print("\nres... | 16,242 |
qemu | c546194f260fb3e391193cb8cc33505618077ecb | 0 | DriveInfo *drive_init(QemuOpts *opts, BlockInterfaceType block_default_type)
{
const char *buf;
const char *file = NULL;
const char *serial;
const char *mediastr = "";
BlockInterfaceType type;
enum { MEDIA_DISK, MEDIA_CDROM } media;
int bus_id, unit_id;
int cyls, heads, secs, tr... | 16,244 |
qemu | 32bafa8fdd098d52fbf1102d5a5e48d29398c0aa | 0 | void hmp_sendkey(Monitor *mon, const QDict *qdict)
{
const char *keys = qdict_get_str(qdict, "keys");
KeyValueList *keylist, *head = NULL, *tmp = NULL;
int has_hold_time = qdict_haskey(qdict, "hold-time");
int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
Error *err = NULL;
char ... | 16,245 |
qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 | 0 | SocketAddressLegacy *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");
... | 16,248 |
qemu | 5a7733b0b728bb4900bdeed12fef22651ce0ab58 | 0 | static int megasas_ctrl_get_info(MegasasState *s, MegasasCmd *cmd)
{
PCIDevice *pci_dev = PCI_DEVICE(s);
struct mfi_ctrl_info info;
size_t dcmd_size = sizeof(info);
BusChild *kid;
int num_ld_disks = 0;
uint16_t sdev_id;
memset(&info, 0x0, cmd->iov_size);
if (cmd->iov_size < dc... | 16,249 |
FFmpeg | a08681f1e614152184615e2bcd71c3d63835f810 | 0 | static int dirac_combine_frame(AVCodecParserContext *s, AVCodecContext *avctx,
int next, const uint8_t **buf, int *buf_size)
{
int parse_timing_info = (s->pts == AV_NOPTS_VALUE &&
s->dts == AV_NOPTS_VALUE);
DiracParseContext *pc = s->priv_data;
... | 16,250 |
qemu | 6890a695d954f33c8a9c4efd3037fdb707fe28ec | 0 | static bool sdhci_can_issue_command(SDHCIState *s)
{
if (!SDHC_CLOCK_IS_ON(s->clkcon) || !(s->pwrcon & SDHC_POWER_ON) ||
(((s->prnsts & SDHC_DATA_INHIBIT) || s->stopped_state) &&
((s->cmdreg & SDHC_CMD_DATA_PRESENT) ||
((s->cmdreg & SDHC_CMD_RESPONSE) == SDHC_CMD_RSP_WITH_BUSY &&
... | 16,251 |
qemu | b00c72180c36510bf9b124e190bd520e3b7e1358 | 0 | target_ulong helper_rdhwr_ccres(CPUMIPSState *env)
{
if ((env->hflags & MIPS_HFLAG_CP0) ||
(env->CP0_HWREna & (1 << 3)))
return env->CCRes;
else
do_raise_exception(env, EXCP_RI, GETPC());
return 0;
}
| 16,253 |
FFmpeg | 2d08f9ea54a347eb0282c227bae359d1a9c3d4bb | 0 | static void vc1_decode_i_blocks(VC1Context *v)
{
int k, j;
MpegEncContext *s = &v->s;
int cbp, val;
uint8_t *coded_val;
int mb_pos;
/* select codingmode used for VLC tables selection */
switch(v->y_ac_table_index){
case 0:
v->codingset = (v->pqindex <= 8) ? CS_HIGH_RA... | 16,258 |
FFmpeg | 0058584580b87feb47898e60e4b80c7f425882ad | 0 | static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t * buf, int buf_size)
{
AC3DecodeContext *ctx = avctx->priv_data;
int frame_start;
int i, j, k, l;
float tmp0[128], tmp1[128], tmp[512];
short *out_samples = (short *)data;
float *samples = ctx->samples... | 16,259 |
qemu | d41f3e750d2c06c613cb1b8db7724f0fbc0a2b14 | 0 | build_srat(GArray *table_data, BIOSLinker *linker, MachineState *machine)
{
AcpiSystemResourceAffinityTable *srat;
AcpiSratMemoryAffinity *numamem;
int i;
int srat_start, numa_start, slots;
uint64_t mem_len, mem_base, next_base;
MachineClass *mc = MACHINE_GET_CLASS(machine);
const ... | 16,260 |
qemu | 973cbd37ce6d4c33dea7f4ed6b8e0e602fa50d25 | 0 | static int net_tap_init(VLANState *vlan, const char *model,
const char *name, const char *ifname1,
const char *setup_script, const char *down_script)
{
TAPState *s;
int fd;
char ifname[128];
if (ifname1 != NULL)
pstrcpy(ifname, sizeof(ifn... | 16,261 |
qemu | dcfd14b3741983c466ad92fa2ae91eeafce3e5d5 | 0 | void helper_icbi(target_ulong addr)
{
addr &= ~(env->dcache_line_size - 1);
/* Invalidate one cache line :
* PowerPC specification says this is to be treated like a load
* (not a fetch) by the MMU. To be sure it will be so,
* do the load "by hand".
*/
ldl(addr);
tb_invalidat... | 16,263 |
FFmpeg | ee9f36a88eb3e2706ea659acb0ca80c414fa5d8a | 0 | static int get_packetheader(NUTContext *nut, ByteIOContext *bc, int prefix_length)
{
int64_t start, size, last_size;
start= url_ftell(bc) - prefix_length;
if(start != nut->packet_start + nut->written_packet_size){
av_log(nut->avf, AV_LOG_ERROR, "get_packetheader called at weird position\n");
... | 16,264 |
qemu | 8b20aefac4ee8874bb9c8826e4b30e1dc8cd7511 | 0 | sdhci_write(void *opaque, hwaddr offset, uint64_t val, unsigned size)
{
SDHCIState *s = (SDHCIState *)opaque;
unsigned shift = 8 * (offset & 0x3);
uint32_t mask = ~(((1ULL << (size * 8)) - 1) << shift);
uint32_t value = val;
value <<= shift;
switch (offset & ~0x3) {
case SDHC_SYSA... | 16,265 |
qemu | 081dd1fe36f0ccc04130d1edd136c787c5f8cc50 | 0 | static void nbd_refresh_limits(BlockDriverState *bs, Error **errp)
{
bs->bl.max_pdiscard = NBD_MAX_BUFFER_SIZE;
bs->bl.max_pwrite_zeroes = NBD_MAX_BUFFER_SIZE;
bs->bl.max_transfer = NBD_MAX_BUFFER_SIZE;
}
| 16,266 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
{
int64_t nb_sectors = bdrv_nb_sectors(bs);
*nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
}
| 16,267 |
qemu | 6d152ebaf4db6567cefbbd3b2b102c4a50172109 | 0 | static void virt_acpi_get_cpu_info(VirtAcpiCpuInfo *cpuinfo)
{
CPUState *cpu;
memset(cpuinfo->found_cpus, 0, sizeof cpuinfo->found_cpus);
CPU_FOREACH(cpu) {
set_bit(cpu->cpu_index, cpuinfo->found_cpus);
}
}
| 16,268 |
qemu | f7613bee32ebd13ff4a8d721a59cf27b1fe5d94b | 0 | static void v9fs_wstat_post_utime(V9fsState *s, V9fsWstatState *vs, int err)
{
if (err < 0) {
goto out;
}
if (vs->v9stat.n_gid != -1) {
if (v9fs_do_chown(s, &vs->fidp->path, vs->v9stat.n_uid,
vs->v9stat.n_gid)) {
err = -errno;
}
}
... | 16,269 |
qemu | 9fd2ecdc8cb2dc1a8a7c57b6c9c60bc9947b6a73 | 0 | static int setfsugid(int uid, int gid)
{
/*
* We still need DAC_OVERRIDE because we don't change
* supplementary group ids, and hence may be subjected DAC rules
*/
cap_value_t cap_list[] = {
CAP_DAC_OVERRIDE,
};
setfsgid(gid);
setfsuid(uid);
if (uid != 0 ||... | 16,271 |
qemu | b0fd8d18683f0d77a8e6b482771ebea82234d727 | 0 | static void target_setup_frame(int usig, struct target_sigaction *ka,
target_siginfo_t *info, target_sigset_t *set,
CPUARMState *env)
{
struct target_rt_sigframe *frame;
abi_ulong frame_addr, return_addr;
frame_addr = get_sigframe(ka, env... | 16,272 |
qemu | 245f7b51c0ea04fb2224b1127430a096c91aee70 | 0 | static bool check_solid_tile(VncState *vs, int x, int y, int w, int h,
uint32_t* color, bool samecolor)
{
VncDisplay *vd = vs->vd;
switch(vd->server->pf.bytes_per_pixel) {
case 4:
return check_solid_tile32(vs, x, y, w, h, color, samecolor);
case 2:
... | 16,273 |
FFmpeg | bcd7bf7eeb09a395cc01698842d1b8be9af483fc | 0 | static void avc_loopfilter_luma_inter_edge_hor_msa(uint8_t *data,
uint8_t bs0, uint8_t bs1,
uint8_t bs2, uint8_t bs3,
uint8_t tc0, uint8_t tc1,
... | 16,275 |
qemu | 9a78eead0c74333a394c0f7bbfc4423ac746fcd5 | 0 | void x86_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
const char *optarg)
{
unsigned char model = !strcmp("?model", optarg);
unsigned char dump = !strcmp("?dump", optarg);
unsigned char cpuid = !strcmp("?cpuid", optarg);
x86_def_t *def;
char buf[256]... | 16,278 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static void dec_misc(DisasContext *dc, uint32_t insn)
{
uint32_t op0, op1;
uint32_t ra, rb, rd;
#ifdef OPENRISC_DISAS
uint32_t L6, K5;
#endif
uint32_t I16, I5, I11, N26, tmp;
TCGMemOp mop;
op0 = extract32(insn, 26, 6);
op1 = extract32(insn, 24, 2);
ra = extract32(insn, 16, 5... | 16,280 |
qemu | dfd100f242370886bb6732f70f1f7cbd8eb9fedc | 0 | int socket_connect(SocketAddress *addr, NonBlockingConnectHandler *callback,
void *opaque, Error **errp)
{
int fd;
switch (addr->type) {
case SOCKET_ADDRESS_KIND_INET:
fd = inet_connect_saddr(addr->u.inet.data, callback, opaque, errp);
break;
case SOCKET_AD... | 16,282 |
FFmpeg | 126524720661a9adddec758e94729007a96f07f7 | 0 | static av_cold int init(AVFilterContext *ctx)
{
FormatContext *s = ctx->priv;
char *cur, *sep;
int nb_formats = 1;
int i;
int ret;
/* count the formats */
cur = s->pix_fmts;
while ((cur = strchr(cur, '|'))) {
nb_formats++;
if (*cur)
cur++;
}... | 16,284 |
qemu | f35e44e7645edbb08e35b111c10c2fc57e2905c7 | 1 | static void tcg_commit(MemoryListener *listener)
{
CPUAddressSpace *cpuas;
AddressSpaceDispatch *d;
/* since each CPU stores ram addresses in its TLB cache, we must
reset the modified entries */
cpuas = container_of(listener, CPUAddressSpace, tcg_as_listener);
cpu_reloading_memory_ma... | 16,285 |
qemu | 1f51470d044852592922f91000e741c381582cdc | 1 | static int qemu_chr_open_null(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr;
chr = g_malloc0(sizeof(CharDriverState));
chr->chr_write = null_chr_write;
*_chr= chr;
return 0;
}
| 16,286 |
qemu | bcfa4d60144fb879f0ffef0a6d174faa37b2df82 | 1 | void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
{
NetClientState *ncs[MAX_QUEUE_NUM];
int count, i, len;
len = strlen(str);
readline_set_completion_index(rs, len);
if (nb_args == 2) {
count = qemu_find_net_clients_except(NULL, ncs,
... | 16,287 |
FFmpeg | 1481e198251192c9801d4e7818c3c23bc217f705 | 1 | int ff_mpeg_update_thread_context(AVCodecContext *dst,
const AVCodecContext *src)
{
MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
if (dst == src || !s1->context_initialized)
return 0;
// FIXME can parameters change on I-frames?
// in that... | 16,288 |
qemu | 9633fcc6a02f23e3ef00aa5fe3fe9c41f57c3456 | 1 | static void init_proc_970FX (CPUPPCState *env)
{
gen_spr_ne_601(env);
gen_spr_7xx(env);
/* Time base */
gen_tbl(env);
/* Hardware implementation registers */
/* XXX : not implemented */
spr_register(env, SPR_HID0, "HID0",
SPR_NOACCESS, SPR_NOACCESS,
... | 16,289 |
FFmpeg | 0871ae1a930122f7124358a0ce3caf81876913a9 | 1 | int av_fifo_generic_read(AVFifoBuffer *f, int buf_size, void (*func)(void*, void*, int), void* dest)
{
int size = av_fifo_size(f);
if (size < buf_size)
return -1;
do {
int len = FFMIN(f->end - f->rptr, buf_size);
if(func) func(dest, f->rptr, len);
else{
... | 16,291 |
FFmpeg | 92e483f8ed70d88d4f64337f65bae212502735d4 | 1 | static int cmp_pkt_sub_ts_pos(const void *a, const void *b)
{
const AVPacket *s1 = a;
const AVPacket *s2 = b;
if (s1->pts == s2->pts) {
if (s1->pos == s2->pos)
return 0;
return s1->pos > s2->pos ? 1 : -1;
}
return s1->pts > s2->pts ? 1 : -1;
}
| 16,292 |
qemu | 3a3b8502e6f0c8d30865c5f36d2c3ae4114000b5 | 1 | static void xics_kvm_realize(DeviceState *dev, Error **errp)
{
KVMXICSState *icpkvm = KVM_XICS(dev);
XICSState *icp = XICS_COMMON(dev);
int i, rc;
Error *error = NULL;
struct kvm_create_device xics_create_device = {
.type = KVM_DEV_TYPE_XICS,
.flags = 0,
};
if (!k... | 16,295 |
FFmpeg | 1edbf5e20c75f06d6987bc823e63aa4e649ccddd | 1 | static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
{
const HEVCSPS *sps = s->ps.sps;
int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
int prev_delta_msb = 0;
unsigned int nb_sps = 0, nb_sh;
int i;
rps->nb_refs = 0;
if (!sps->long_term_ref_pics_present_fla... | 16,296 |
qemu | 33876dfad64bc481f59c5e9ccf60db78624c4b93 | 1 | static void xenstore_update_be(char *watch, char *type, int dom,
struct XenDevOps *ops)
{
struct XenDevice *xendev;
char path[XEN_BUFSIZE], *dom0, *bepath;
unsigned int len, dev;
dom0 = xs_get_domain_path(xenstore, 0);
len = snprintf(path, sizeof(path), "%s/ba... | 16,297 |
FFmpeg | cfda1bea4c18ec1edbc11ecc465f788b02851488 | 1 | static int open_url(HLSContext *c, URLContext **uc, const char *url, AVDictionary *opts)
{
AVDictionary *tmp = NULL;
int ret;
const char *proto_name = avio_find_protocol_name(url);
// only http(s) & file are allowed
if (!av_strstart(proto_name, "http", NULL) && !av_strstart(proto_name, "file",... | 16,298 |
FFmpeg | 52537534d20c675d3c53cdad160dd3462fbfef30 | 1 | static int rm_assemble_video_frame(AVFormatContext *s, RMContext *rm, AVPacket *pkt, int len)
{
ByteIOContext *pb = &s->pb;
int hdr, seq, pic_num, len2, pos;
int type;
int ssize;
hdr = get_byte(pb); len--;
type = hdr >> 6;
switch(type){
case 0: // slice
case 2: // last sl... | 16,299 |
FFmpeg | 1bbb173652605053ed9ed2fea20ee7205ea19e0e | 0 | static int sunrast_decode_frame(AVCodecContext *avctx, void *data,
int *data_size, AVPacket *avpkt) {
const uint8_t *buf = avpkt->data;
const uint8_t *buf_end = avpkt->data + avpkt->size;
SUNRASTContext * const s = avctx->priv_data;
AVFrame *picture = data;
AVFr... | 16,300 |
qemu | cb78466ef60ccf707a6f38a1294c435b65a828e0 | 0 | static void external_snapshot_prepare(BlkTransactionStates *common,
Error **errp)
{
BlockDriver *proto_drv;
BlockDriver *drv;
int flags, ret;
Error *local_err = NULL;
const char *device;
const char *new_image_file;
const char *format = "qcow2";
... | 16,301 |
qemu | 8607f5c3072caeebbe0217df28651fffd3a79fd9 | 0 | static void virtqueue_map_iovec(struct iovec *sg, hwaddr *addr,
unsigned int *num_sg, unsigned int max_size,
int is_write)
{
unsigned int i;
hwaddr len;
/* Note: this function MUST validate input, some callers
* are passing in num... | 16,302 |
qemu | 818584a43ab0ef52c131865128ef110f867726cd | 0 | static void bdrv_inherited_options(int *child_flags, QDict *child_options,
int parent_flags, QDict *parent_options)
{
int flags = parent_flags;
/* Enable protocol handling, disable format probing for bs->file */
flags |= BDRV_O_PROTOCOL;
/* If the cache mode ... | 16,303 |
qemu | eabb7b91b36b202b4dac2df2d59d698e3aff197a | 0 | static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, intptr_t arg2)
{
int opi, opx;
assert(TCG_TARGET_REG_BITS == 64 || type == TCG_TYPE_I32);
if (type == TCG_TYPE_I32) {
opi = STW, opx = STWX;
} else {
opi = STD, opx... | 16,304 |
qemu | 9f1d4b1d6939d39fe570d886f6a651f4764bcbcb | 0 | static void IRQ_local_pipe(OpenPICState *opp, int n_CPU, int n_IRQ)
{
IRQDest *dst;
IRQSource *src;
int priority;
dst = &opp->dst[n_CPU];
src = &opp->src[n_IRQ];
if (src->output != OPENPIC_OUTPUT_INT) {
/* On Freescale MPIC, critical interrupts ignore priority,
* IA... | 16,306 |
qemu | 03010579835a17450693888f8b35a66817668d68 | 0 | static void test_acpi_dsdt_table(test_data *data)
{
AcpiSdtTable dsdt_table;
uint32_t addr = le32_to_cpu(data->fadt_table.dsdt);
test_dst_table(&dsdt_table, addr);
ACPI_ASSERT_CMP(dsdt_table.header.signature, "DSDT");
/* Since DSDT isn't in RSDT, add DSDT to ASL test tables list manually *... | 16,308 |
qemu | 7df9381b7aa56c897e344f3bfe43bf5848bbd3e0 | 0 | static void vfio_err_notifier_handler(void *opaque)
{
VFIOPCIDevice *vdev = opaque;
if (!event_notifier_test_and_clear(&vdev->err_notifier)) {
return;
}
/*
* TBD. Retrieve the error details and decide what action
* needs to be taken. One of the actions could be to pass
... | 16,309 |
qemu | 891fb2cd4592b6fe76106a69e0ca40efbf82726a | 0 | static int do_attach(USBDevice *dev)
{
USBBus *bus = usb_bus_from_device(dev);
USBPort *port;
if (dev->attached) {
error_report("Error: tried to attach usb device %s twice\n",
dev->product_desc);
return -1;
}
if (bus->nfree == 0) {
error_report("Er... | 16,310 |
FFmpeg | cfd937b081adfa122e3f814b928c9ea0ada7f4f0 | 0 | static void apply_dependent_coupling(AACContext * ac, SingleChannelElement * target, ChannelElement * cce, int index) {
IndividualChannelStream * ics = &cce->ch[0].ics;
const uint16_t * offsets = ics->swb_offset;
float * dest = target->coeffs;
const float * src = cce->ch[0].coeffs;
int g, i, gr... | 16,311 |
qemu | b854bc196f5c4b4e3299c0b0ee63cf828ece9e77 | 0 | static inline void omap_timer_update(struct omap_mpu_timer_s *timer)
{
int64_t expires;
if (timer->enable && timer->st && timer->rate) {
timer->val = timer->reset_val; /* Should skip this on clk enable */
expires = timer->time + muldiv64(timer->val << (timer->ptv + 1),
... | 16,312 |
qemu | 2436b61a6b386d712a1813b036921443bd1c5c39 | 0 | void cpu_save(QEMUFile *f, void *opaque)
{
CPUState *env = opaque;
uint16_t fptag, fpus, fpuc, fpregs_format;
uint32_t hflags;
int32_t a20_mask;
int i;
for(i = 0; i < CPU_NB_REGS; i++)
qemu_put_betls(f, &env->regs[i]);
qemu_put_betls(f, &env->eip);
qemu_put_betls(f, &... | 16,313 |
qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 | 0 | static void omap_mcbsp_source_tick(void *opaque)
{
struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
static const int bps[8] = { 0, 1, 1, 2, 2, 2, -255, -255 };
if (!s->rx_rate)
return;
if (s->rx_req)
printf("%s: Rx FIFO overrun\n", __FUNCTION__);
s->rx_req = s->rx... | 16,314 |
qemu | f23ef34a5dec56103e1348a622a6adf7c87c821f | 0 | static int xen_9pfs_free(struct XenDevice *xendev)
{
return -1;
}
| 16,315 |
qemu | 6092666ebdc68b2634db050689292c71a5c368c0 | 0 | static void phys_sections_clear(PhysPageMap *map)
{
while (map->sections_nb > 0) {
MemoryRegionSection *section = &map->sections[--map->sections_nb];
phys_section_destroy(section->mr);
}
g_free(map->sections);
g_free(map->nodes);
}
| 16,316 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.