project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
FFmpeg | ee7f2609a0dcac4008759f20ab9558a68d759821 | 0 | static void reanalyze(MpegTSContext *ts) {
AVIOContext *pb = ts->stream->pb;
int64_t pos = avio_tell(pb);
if(pos < 0)
return;
pos += ts->raw_packet_size - ts->pos47_full;
if (pos == TS_PACKET_SIZE) {
ts->size_stat[0] ++;
} else if (pos == TS_DVHS_PACKET_SIZE) {
t... | 9,966 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | static void spapr_create_nvram(sPAPREnvironment *spapr)
{
DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram");
DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0);
if (dinfo) {
qdev_prop_set_drive_nofail(dev, "drive",
blk_bs(blk_by_legacy_dinfo(di... | 9,967 |
qemu | 2119882c7eb7e2c612b24fc0c8d86f5887d6f1c3 | 0 | void qmp_block_dirty_bitmap_remove(const char *node, const char *name,
Error **errp)
{
AioContext *aio_context;
BlockDriverState *bs;
BdrvDirtyBitmap *bitmap;
bitmap = block_dirty_bitmap_lookup(node, name, &bs, &aio_context, errp);
if (!bitmap || !bs) {
... | 9,968 |
qemu | 8d8fdbae010aa75a23f0307172e81034125aba6e | 0 | int tcg_gen_code(TCGContext *s, TranslationBlock *tb)
{
int i, oi, oi_next, num_insns;
#ifdef CONFIG_PROFILER
{
int n;
n = s->gen_last_op_idx + 1;
s->op_count += n;
if (n > s->op_count_max) {
s->op_count_max = n;
}
n = s->nb_temps;
... | 9,970 |
qemu | ba3186c4e473963ba83b5792f3d02d4ac0a76ba5 | 0 | static void curl_multi_read(void *arg)
{
CURLState *s = (CURLState *)arg;
aio_context_acquire(s->s->aio_context);
curl_multi_do_locked(s);
curl_multi_check_completion(s->s);
aio_context_release(s->s->aio_context);
}
| 9,971 |
qemu | ae2ebad7331930280324005c06bc0891f02eef53 | 0 | static int sh_pci_host_init(PCIDevice *d)
{
pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_HITACHI);
pci_config_set_device_id(d->config, PCI_DEVICE_ID_HITACHI_SH7751R);
pci_set_word(d->config + PCI_COMMAND, PCI_COMMAND_WAIT);
pci_set_word(d->config + PCI_STATUS, PCI_STATUS_CAP_LIST |
... | 9,972 |
qemu | 1c275925bfbbc2de84a8f0e09d1dd70bbefb6da3 | 0 | static int do_sigframe_return_v2(CPUARMState *env, target_ulong frame_addr,
struct target_ucontext_v2 *uc)
{
sigset_t host_set;
abi_ulong *regspace;
target_to_host_sigset(&host_set, &uc->tuc_sigmask);
sigprocmask(SIG_SETMASK, &host_set, NULL);
if (restore_... | 9,973 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
int nb_sectors)
{
if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
return -EIO;
}
return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
... | 9,974 |
qemu | 64e07be544ee9c5fb5b741175262fd34726ec431 | 0 | static int kvm_arch_sync_sregs(CPUState *cenv)
{
struct kvm_sregs sregs;
int ret;
if (cenv->excp_model == POWERPC_EXCP_BOOKE) {
return 0;
} else {
if (!cap_segstate) {
return 0;
}
}
ret = kvm_vcpu_ioctl(cenv, KVM_GET_SREGS, &sregs);
if (ret... | 9,975 |
qemu | 4ef0defbad9bc8b195f3392d1b7dcb42cd7ebe11 | 0 | static int net_client_init1(const void *object, int is_netdev, Error **errp)
{
union {
const Netdev *netdev;
const NetLegacy *net;
} u;
const NetClientOptions *opts;
const char *name;
if (is_netdev) {
u.netdev = object;
opts = u.netdev->opts;
n... | 9,976 |
qemu | e1833e1f96456fd8fc17463246fe0b2050e68efb | 0 | static inline void gen_evsel (DisasContext *ctx)
{
if (unlikely(!ctx->spe_enabled)) {
RET_EXCP(ctx, EXCP_NO_SPE, 0);
return;
}
gen_op_load_crf_T0(ctx->opcode & 0x7);
gen_op_load_gpr64_T0(rA(ctx->opcode));
gen_op_load_gpr64_T1(rB(ctx->opcode));
gen_op_evsel();
gen_op... | 9,978 |
qemu | bd4b65ee5e5f750da709ac10c70266876e515c23 | 1 | int pci_device_load(PCIDevice *s, QEMUFile *f)
{
uint32_t version_id;
int i;
version_id = qemu_get_be32(f);
if (version_id > 2)
return -EINVAL;
qemu_get_buffer(f, s->config, 256);
pci_update_mappings(s);
if (version_id >= 2)
for (i = 0; i < 4; i ++)
... | 9,979 |
FFmpeg | 67bbaed5c498212bdd70b13b4fdcb37f4c9c77f5 | 0 | int ff_hevc_decode_nal_vps(HEVCContext *s)
{
int i,j;
GetBitContext *gb = &s->HEVClc.gb;
int vps_id = 0;
HEVCVPS *vps;
AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
if (!vps_buf)
return AVERROR(ENOMEM);
vps = (HEVCVPS*)vps_buf->data;
av_log(s->avctx, AV_LOG_D... | 9,980 |
FFmpeg | da2e774fd6841da7cede8c8ef30337449329727c | 1 | static int decode_frame(AVCodecContext * avctx, void *data, int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
KmvcContext *const ctx = avctx->priv_data;
uint8_t *out, *src;
int i;
int header;
int blocksize;
const uint8_t *pal = av_p... | 9,981 |
FFmpeg | a27227d401adf12534dc7a26d72e43e2f35f8944 | 1 | static int read_header(FFV1Context *f)
{
uint8_t state[CONTEXT_SIZE];
int i, j, context_count = -1; //-1 to avoid warning
RangeCoder *const c = &f->slice_context[0]->c;
memset(state, 128, sizeof(state));
if (f->version < 2) {
int chroma_planes, chroma_h_shift, chroma_v_shift, tran... | 9,982 |
FFmpeg | 38d553322891c8e47182f05199d19888422167dc | 1 | static int config_props(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = outlink->src->inputs[0];
ScaleContext *scale = ctx->priv;
int64_t w, h;
double var_values[VARS_NB], res;
char *expr;
int ret;
var_values[VAR_PI] = M_PI;
var_val... | 9,983 |
FFmpeg | 077b55943330150db0eafd36bbee614697cabd98 | 1 | static int set_sps(HEVCContext *s, const HEVCSPS *sps)
{
#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL)
enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
int ret;
export_stream_params(s->avctx, &s->ps, sps);
pic_arrays_free(s);
ret = pic_arr... | 9,984 |
FFmpeg | 0ecca7a49f8e254c12a3a1de048d738bfbb614c6 | 1 | static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
int buf_size, void *data)
{
SVQ1Context * const s = avctx->priv_data;
AVFrame *pict = data;
AVFrame * const p= (AVFrame*)&s->picture;
AVFrame temp;
int i;
if(avctx->pix_fmt != PIX_FMT_YUV410P){
av_log... | 9,985 |
qemu | a1f0cce2ac0243572ff72aa561da67fe3766a395 | 1 | static void scsi_dma_restart_bh(void *opaque)
{
SCSIDiskState *s = opaque;
SCSIRequest *req;
SCSIDiskReq *r;
qemu_bh_delete(s->bh);
s->bh = NULL;
QTAILQ_FOREACH(req, &s->qdev.requests, next) {
r = DO_UPCAST(SCSIDiskReq, req, req);
if (r->status & SCSI_REQ_STATUS_RETR... | 9,986 |
qemu | 0ead93120eb7bd770b32adc00b5ec1ee721626dc | 1 | static bool is_sector_request_lun_aligned(int64_t sector_num, int nb_sectors,
IscsiLun *iscsilun)
{
assert(nb_sectors < BDRV_REQUEST_MAX_SECTORS);
return is_byte_request_lun_aligned(sector_num << BDRV_SECTOR_BITS,
nb_sectors <... | 9,987 |
FFmpeg | 2aab7c2dfaca4386c38e5d565cd2bf73096bcc86 | 0 | void ff_put_h264_qpel16_mc11_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_hv_qrt_16w_msa(src - 2,
src - (stride * 2), stride, dst, stride, 16);
}
| 9,988 |
FFmpeg | 4e8d01f20ce82b49f47c704a461c5d30866affaf | 0 | static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
{
MpegTSContext *ts = filter->u.section_filter.opaque;
MpegTSSectionFilter *tssf = &filter->u.section_filter;
SectionHeader h1, *h = &h1;
PESContext *pes;
AVStream *st;
const uint8_t *p, *p_end, *desc_list_e... | 9,989 |
FFmpeg | be42c0b8d57fe2ea769892d102ffd5561dc18709 | 0 | static int rm_read_packet(AVFormatContext *s, AVPacket *pkt)
{
RMDemuxContext *rm = s->priv_data;
AVStream *st;
int i, len, res, seq = 1;
int64_t timestamp, pos;
int flags;
for (;;) {
if (rm->audio_pkt_cnt) {
// If there are queued audio packet return them first
... | 9,990 |
FFmpeg | 6f5c00eb9f8d3cbb100cbd4022f061914e10dfa1 | 0 | static int decode_group3_2d_line(AVCodecContext *avctx, GetBitContext *gb,
int width, int *runs, const int *runend, const int *ref)
{
int mode = 0, offs = 0, run = 0, saved_run = 0, t;
int run_off = *ref++;
int *run_start = runs;
runend--; // for the last written... | 9,991 |
FFmpeg | ee7a642b0e5da1730cfc66008d2f2976fa37a692 | 0 | static int analyze(const uint8_t *buf, int size, int packet_size, int *index,
int probe)
{
int stat[TS_MAX_PACKET_SIZE];
int stat_all = 0;
int i;
int best_score = 0;
memset(stat, 0, packet_size * sizeof(*stat));
for (i = 0; i < size - 3; i++) {
if (buf[i] ... | 9,992 |
FFmpeg | 1d16a1cf99488f16492b1bb48e023f4da8377e07 | 0 | static void ff_h264_idct_dc_add8_mmx2(uint8_t *dst, int16_t *block, int stride)
{
__asm__ volatile(
"movd %0, %%mm0 \n\t" // 0 0 X D
"punpcklwd %1, %%mm0 \n\t" // x X d D
"paddsw %2, %%mm0 \n\t"
"psraw $6, %%mm0 \n\t"
"punp... | 9,993 |
FFmpeg | d319064465e148b8adb53d1ea5d38c09f987056e | 0 | void uninit_opts(void)
{
int i;
for (i = 0; i < AVMEDIA_TYPE_NB; i++)
av_freep(&avcodec_opts[i]);
av_freep(&avformat_opts->key);
av_freep(&avformat_opts);
#if CONFIG_SWSCALE
av_freep(&sws_opts);
#endif
for (i = 0; i < opt_name_count; i++) {
//opt_values are only stored... | 9,994 |
FFmpeg | 247e658784ead984f96021acb9c95052ba599f26 | 0 | static int ftp_send_command(FTPContext *s, const char *command,
const int response_codes[], char **response)
{
int err;
/* Flush control connection input to get rid of non relevant responses if any */
if ((err = ftp_flush_control_input(s)) < 0)
return err;
... | 9,995 |
FFmpeg | 2df0c32ea12ddfa72ba88309812bfb13b674130f | 0 | static int libvorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr)
{
LibvorbisContext *s = avctx->priv_data;
ogg_packet op;
int ret, duration;
/* send samples to libvorbis */
if (frame) {
const int ... | 9,996 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | int bdrv_set_key(BlockDriverState *bs, const char *key)
{
int ret;
if (bs->backing_hd && bs->backing_hd->encrypted) {
ret = bdrv_set_key(bs->backing_hd, key);
if (ret < 0)
return ret;
if (!bs->encrypted)
return 0;
}
if (!bs->encrypted) {
... | 9,997 |
qemu | de08c606f9ddafe647b6843e2b10a6d6030b0fc0 | 0 | int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id)
{
BlockDriver *drv = bs->drv;
if (!drv)
return -ENOMEDIUM;
if (drv->bdrv_snapshot_delete)
return drv->bdrv_snapshot_delete(bs, snapshot_id);
if (bs->file)
return bdrv_snapshot_delete(bs->file, snapsho... | 9,998 |
qemu | a5cf8262e4eb9c4646434e2c6211ef8608db3233 | 0 | static char *idebus_get_fw_dev_path(DeviceState *dev)
{
char path[30];
snprintf(path, sizeof(path), "%s@%d", qdev_fw_name(dev),
((IDEBus*)dev->parent_bus)->bus_id);
return strdup(path);
}
| 9,999 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | int bdrv_key_required(BlockDriverState *bs)
{
BlockDriverState *backing_hd = bs->backing_hd;
if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key)
return 1;
return (bs->encrypted && !bs->valid_key);
}
| 10,001 |
qemu | bbc01ca7f265f2c5be8aee7c9ce1d10aa26063f5 | 0 | static void init_proc_970 (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,
... | 10,002 |
qemu | 0524e93a3fd7bff5bb4a584c372f2632ab7c0e0f | 0 | void qmp_drive_mirror(DriveMirror *arg, Error **errp)
{
BlockDriverState *bs;
BlockBackend *blk;
BlockDriverState *source, *target_bs;
AioContext *aio_context;
BlockMirrorBackingMode backing_mode;
Error *local_err = NULL;
QDict *options = NULL;
int flags;
int64_t size;
... | 10,003 |
FFmpeg | 7631f14bb35e8467d4ffaaa2b34e60614eb37c71 | 0 | static int get_aac_sample_rates(AVFormatContext *s, AVCodecParameters *par,
int *sample_rate, int *output_sample_rate)
{
MPEG4AudioConfig mp4ac;
if (avpriv_mpeg4audio_get_config(&mp4ac, par->extradata,
par->extradata_size * 8, 1) < 0) {... | 10,005 |
qemu | c1076c3e13a86140cc2ba29866512df8460cc7c2 | 0 | static void pxa2xx_lcdc_dma0_redraw_rot270(PXA2xxLCDState *s,
hwaddr addr, int *miny, int *maxy)
{
DisplaySurface *surface = qemu_console_surface(s->con);
int src_width, dest_width;
drawfn fn = NULL;
if (s->dest_width) {
fn = s->line_fn[s->transp][s->bpp];
}
if (!... | 10,006 |
qemu | eabb7b91b36b202b4dac2df2d59d698e3aff197a | 0 | static void tci_out_label(TCGContext *s, TCGLabel *label)
{
if (label->has_value) {
tcg_out_i(s, label->u.value);
assert(label->u.value);
} else {
tcg_out_reloc(s, s->code_ptr, sizeof(tcg_target_ulong), label, 0);
s->code_ptr += sizeof(tcg_target_ulong);
}
}
| 10,007 |
qemu | e37e6ee6e100ebc355b4a48ae9a7802b38b8dac0 | 0 | void tlb_flush(CPUState *env, int flush_global)
{
int i;
#if defined(DEBUG_TLB)
printf("tlb_flush:\n");
#endif
/* must reset current TB so that interrupts cannot modify the
links while we are modifying them */
env->current_tb = NULL;
for(i = 0; i < CPU_TLB_SIZE; i++) {
e... | 10,008 |
qemu | 2cac260768b9d4253737417ea7501cf2950e257f | 0 | static int write_elf64_load(DumpState *s, MemoryMapping *memory_mapping,
int phdr_index, hwaddr offset)
{
Elf64_Phdr phdr;
int ret;
int endian = s->dump_info.d_endian;
memset(&phdr, 0, sizeof(Elf64_Phdr));
phdr.p_type = cpu_convert_to_target32(PT_LOAD, endian);
... | 10,009 |
qemu | a1f910875668d87e139e79fce38e9c2e1c3747dd | 0 | static int patch_hypercalls(VAPICROMState *s)
{
hwaddr rom_paddr = s->rom_state_paddr & ROM_BLOCK_MASK;
static const uint8_t vmcall_pattern[] = { /* vmcall */
0xb8, 0x1, 0, 0, 0, 0xf, 0x1, 0xc1
};
static const uint8_t outl_pattern[] = { /* nop; outl %eax,0x7e */
0xb8, 0x1, 0, 0, 0... | 10,010 |
qemu | 245f7b51c0ea04fb2224b1127430a096c91aee70 | 0 | static void vnc_zlib_start(VncState *vs)
{
buffer_reset(&vs->zlib);
// make the output buffer be the zlib buffer, so we can compress it later
vs->zlib_tmp = vs->output;
vs->output = vs->zlib;
}
| 10,011 |
qemu | b00c72180c36510bf9b124e190bd520e3b7e1358 | 0 | target_ulong helper_rdhwr_cpunum(CPUMIPSState *env)
{
if ((env->hflags & MIPS_HFLAG_CP0) ||
(env->CP0_HWREna & (1 << 0)))
return env->CP0_EBase & 0x3ff;
else
do_raise_exception(env, EXCP_RI, GETPC());
return 0;
}
| 10,012 |
qemu | e23e400ec62a03dea58ddb38479b4f1ef86f556d | 0 | static int write_l1_entry(BlockDriverState *bs, int l1_index)
{
BDRVQcowState *s = bs->opaque;
uint64_t buf[L1_ENTRIES_PER_SECTOR];
int l1_start_index;
int i, ret;
l1_start_index = l1_index & ~(L1_ENTRIES_PER_SECTOR - 1);
for (i = 0; i < L1_ENTRIES_PER_SECTOR; i++) {
buf[i] = c... | 10,014 |
FFmpeg | 4a6a29a7fbf023b19797c38a86099d9f81d25524 | 0 | static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
AMRWBContext *s = avctx->priv_data;
int mode;
int packet_size;
static const uint8_t b... | 10,016 |
qemu | 7bd427d801e1e3293a634d3c83beadaa90ffb911 | 0 | static void gui_update(void *opaque)
{
uint64_t interval = GUI_REFRESH_INTERVAL;
DisplayState *ds = opaque;
DisplayChangeListener *dcl = ds->listeners;
qemu_flush_coalesced_mmio_buffer();
dpy_refresh(ds);
while (dcl != NULL) {
if (dcl->gui_timer_interval &&
dcl->... | 10,017 |
qemu | a1aa1309892581972b5019ef65fd0a12cd69cc28 | 0 | static void spapr_phb_vfio_instance_init(Object *obj)
{
error_report("spapr-pci-vfio-host-bridge is deprecated");
}
| 10,019 |
qemu | a0b753dfd3920df146a5f4d05e442e3c522900c7 | 0 | static void connex_init(ram_addr_t ram_size, int vga_ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
struct pxa2xx_state_s *cpu;
int index;
uint32_t conn... | 10,021 |
qemu | 51b19ebe4320f3dcd93cea71235c1219318ddfd2 | 0 | static void handle_notify(EventNotifier *e)
{
VirtIOBlockDataPlane *s = container_of(e, VirtIOBlockDataPlane,
host_notifier);
VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);
event_notifier_test_and_clear(&s->host_notifier);
blk_io_plug(s->conf->conf.blk);
... | 10,022 |
qemu | 0ae18ceeaaa2c1749e742c4b112f6c3bf0896408 | 0 | static void mcf5208evb_init(ram_addr_t ram_size, int vga_ram_size,
const char *boot_device, DisplayState *ds,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
CPUState *env;
int ker... | 10,023 |
qemu | e1c7f0e3f998866bedc9bdb53d247859b7beb5ce | 0 | static int qcow_read_extensions(BlockDriverState *bs, uint64_t start_offset,
uint64_t end_offset)
{
BDRVQcowState *s = bs->opaque;
QCowExtension ext;
uint64_t offset;
#ifdef DEBUG_EXT
printf("qcow_read_extensions: start=%ld end=%ld\n", start_offset, end_offset);
... | 10,024 |
qemu | c5619bf9e8935aeb972c0bd935549e9ee0a739f2 | 0 | int armv7m_nvic_acknowledge_irq(void *opaque)
{
nvic_state *s = (nvic_state *)opaque;
uint32_t irq;
irq = gic_acknowledge_irq(&s->gic, 0);
if (irq == 1023)
hw_error("Interrupt but no vector\n");
if (irq >= 32)
irq -= 16;
return irq;
}
| 10,025 |
qemu | 374f2981d1f10bc4307f250f24b2a7ddb9b14be0 | 0 | static FlatView *address_space_get_flatview(AddressSpace *as)
{
FlatView *view;
qemu_mutex_lock(&flat_view_mutex);
view = as->current_map;
flatview_ref(view);
qemu_mutex_unlock(&flat_view_mutex);
return view;
}
| 10,027 |
qemu | 076796f8fd27f4d014fe2efb6372f1cdc1df9a41 | 0 | static int kvm_put_vcpu_events(X86CPU *cpu, int level)
{
CPUX86State *env = &cpu->env;
struct kvm_vcpu_events events;
if (!kvm_has_vcpu_events()) {
return 0;
}
events.exception.injected = (env->exception_injected >= 0);
events.exception.nr = env->exception_injected;
even... | 10,028 |
FFmpeg | d00bff20b2b48796e4bd2d0b83819c159f60a25f | 0 | static int qdm2_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
QDM2Context *s = avctx->priv_data;
if((buf == NULL) || (buf_size < s->checksum_size))
return 0;
*data_size = s->channels * s->frame_size * sizeof(int16_t);... | 10,029 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | static void bdrv_sync_complete(void *opaque, int ret)
{
/* do nothing. Masters do not directly interact with the backing store,
* only the working copy so no mutexing required.
*/
}
| 10,030 |
qemu | 1195fed9e6790bd8fd86b0dc33e2442d70355ac6 | 0 | set_phy_ctrl(E1000State *s, int index, uint16_t val)
{
/*
* QEMU 1.3 does not support link auto-negotiation emulation, so if we
* migrate during auto negotiation, after migration the link will be
* down.
*/
if (!(s->compat_flags & E1000_FLAG_AUTONEG)) {
return;
}
if... | 10,031 |
qemu | 37f51384ae05bd50f83308339dbffa3e78404874 | 0 | static void vtd_address_space_unmap(VTDAddressSpace *as, IOMMUNotifier *n)
{
IOMMUTLBEntry entry;
hwaddr size;
hwaddr start = n->start;
hwaddr end = n->end;
/*
* Note: all the codes in this function has a assumption that IOVA
* bits are no more than VTD_MGAW bits (which is restri... | 10,032 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | static int megasas_ld_get_info_submit(SCSIDevice *sdev, int lun,
MegasasCmd *cmd)
{
struct mfi_ld_info *info = cmd->iov_buf;
size_t dcmd_size = sizeof(struct mfi_ld_info);
uint8_t cdb[6];
SCSIRequest *req;
ssize_t len, resid;
BlockConf *conf = &sdev-... | 10,033 |
qemu | 3b22c4707decb706b10ce023534f8b79413ff9fe | 0 | static void do_interrupt_protected(int intno, int is_int, int error_code,
unsigned int next_eip)
{
SegmentCache *dt;
uint8_t *ptr, *ssp;
int type, dpl, selector, ss_dpl;
int has_error_code, new_stack, shift;
uint32_t e1, e2, offset, ss, esp, ss_e1, ss_e2, pu... | 10,035 |
qemu | 27a69bb088bee6d4efea254659422fb9c751b3c7 | 0 | static inline void gen_evmergehilo(DisasContext *ctx)
{
if (unlikely(!ctx->spe_enabled)) {
gen_exception(ctx, POWERPC_EXCP_APU);
return;
}
#if defined(TARGET_PPC64)
TCGv t0 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
tcg_gen_ext32u_tl(t0, cpu_gpr[rB(ctx->opcode)]);
tcg_... | 10,036 |
qemu | 17b74b98676aee5bc470b173b1e528d2fce2cf18 | 0 | void qjson_finish(QJSON *json)
{
json_end_object(json);
}
| 10,037 |
qemu | dcfd14b3741983c466ad92fa2ae91eeafce3e5d5 | 0 | static void arm_cache_flush(abi_ulong start, abi_ulong last)
{
abi_ulong addr, last1;
if (last < start)
return;
addr = start;
for(;;) {
last1 = ((addr + TARGET_PAGE_SIZE) & TARGET_PAGE_MASK) - 1;
if (last1 > last)
last1 = last;
tb_invalidate_page_r... | 10,038 |
qemu | acc4af3fec335bb0778456f72bfb2c3591c11da4 | 0 | Object *object_dynamic_cast(Object *obj, const char *typename)
{
GSList *i;
/* Check if typename is a direct ancestor */
if (object_is_type(obj, typename)) {
return obj;
}
/* Check if obj has an interface of typename */
for (i = obj->interfaces; i; i = i->next) {
Int... | 10,039 |
qemu | 7e01376daea75e888c370aab521a7d4aeaf2ffd1 | 0 | void ioinst_handle_rchp(S390CPU *cpu, uint64_t reg1)
{
int cc;
uint8_t cssid;
uint8_t chpid;
int ret;
CPUS390XState *env = &cpu->env;
if (RCHP_REG1_RES(reg1)) {
program_interrupt(env, PGM_OPERAND, 2);
return;
}
cssid = RCHP_REG1_CSSID(reg1);
chpid = RC... | 10,040 |
qemu | 74b4c74d5efb0a489bdf0acc5b5d0197167e7649 | 0 | int s390_cpu_restart(S390CPU *cpu)
{
if (kvm_enabled()) {
return kvm_s390_cpu_restart(cpu);
}
return -ENOSYS;
}
| 10,041 |
FFmpeg | 3deb4b54a24f8cddce463d9f5751b01efeb976af | 0 | static int parse_packet_header(WMAVoiceContext *s)
{
GetBitContext *gb = &s->gb;
unsigned int res;
if (get_bits_left(gb) < 11)
return 1;
skip_bits(gb, 4); // packet sequence number
s->has_residual_lsps = get_bits1(gb);
do {
res = get_bits(gb, 6); // number of ... | 10,042 |
qemu | 9c5ce8db2e5c2769ed2fd3d91928dd1853b5ce7c | 0 | int xenstore_domain_init1(const char *kernel, const char *ramdisk,
const char *cmdline)
{
char *dom, uuid_string[42], vm[256], path[256];
int i;
snprintf(uuid_string, sizeof(uuid_string), UUID_FMT,
qemu_uuid[0], qemu_uuid[1], qemu_uuid[2], qemu_uuid[3],
... | 10,043 |
FFmpeg | da4c7cce2100a4e4f9276b4f17e260be47b53f41 | 0 | static av_always_inline void put_h264_qpel8or16_hv1_lowpass_sse2(int16_t *tmp, uint8_t *src, int tmpStride, int srcStride, int size){
int w = (size+8)>>3;
src -= 2*srcStride+2;
while(w--){
__asm__ volatile(
"pxor %%xmm7, %%xmm7 \n\t"
"movq (%0), %%xmm0 \... | 10,044 |
qemu | a0ceb640d083ab583d115fbd2ded14c089044ae8 | 0 | static void pc_cpu_pre_plug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
int idx;
int node_id;
CPUState *cs;
CPUArchId *cpu_slot;
X86CPUTopoInfo topo;
X86CPU *cpu = X86_CPU(dev);
PCMachineState *pcms = PC_MACHINE(hotplug_dev);
/* ... | 10,045 |
qemu | bc0129d97804615fbcf3281fe30361ab8aa8f4ab | 0 | void monitor_readline(const char *prompt, int is_password,
char *buf, int buf_size)
{
int i;
if (is_password) {
for (i = 0; i < MAX_MON; i++)
if (monitor_hd[i] && monitor_hd[i]->focus == 0)
qemu_chr_send_event(monitor_hd[i], CHR_EVENT_FOCUS);
... | 10,046 |
FFmpeg | 11b47038135442ec546dc348f2411e52e47549b8 | 0 | static void decode_422_bitstream(HYuvContext *s, int count)
{
int i;
count /= 2;
if (count >= (get_bits_left(&s->gb)) / (31 * 4)) {
for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
READ_2PIX(s->temp[0][2 * i ], s->temp[1][i], 1);
READ_2PIX(s->temp[0][2... | 10,047 |
qemu | 1ea879e5580f63414693655fcf0328559cdce138 | 0 | static int oss_init_out (HWVoiceOut *hw, audsettings_t *as)
{
OSSVoiceOut *oss = (OSSVoiceOut *) hw;
struct oss_params req, obt;
int endianness;
int err;
int fd;
audfmt_e effective_fmt;
audsettings_t obt_as;
oss->fd = -1;
req.fmt = aud_to_ossfmt (as->fmt);
req.freq... | 10,048 |
qemu | cc943c36faa192cd4b32af8fe5edb31894017d35 | 0 | void msi_notify(PCIDevice *dev, unsigned int vector)
{
uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev));
bool msi64bit = flags & PCI_MSI_FLAGS_64BIT;
unsigned int nr_vectors = msi_nr_vectors(flags);
MSIMessage msg;
assert(vector < nr_vectors);
if (msi_is_masked(dev, vecto... | 10,050 |
qemu | f53a829bb9ef14be800556cbc02d8b20fc1050a7 | 0 | int nbd_client_session_init(NbdClientSession *client, BlockDriverState *bs,
int sock, const char *export, Error **errp)
{
int ret;
/* NBD handshake */
logout("session init %s\n", export);
qemu_set_block(sock);
ret = nbd_receive_negotiate(sock, export,
... | 10,051 |
qemu | d9f62dde1303286b24ac8ce88be27e2b9b9c5f46 | 0 | static void qmp_output_push_obj(QmpOutputVisitor *qov, QObject *value)
{
QStackEntry *e = g_malloc0(sizeof(*e));
assert(qov->root);
assert(value);
e->value = value;
if (qobject_type(e->value) == QTYPE_QLIST) {
e->is_list_head = true;
}
QTAILQ_INSERT_HEAD(&qov->stack, e, no... | 10,052 |
qemu | 4ffdb337e74f9a4dae97ea0396d4e1a3dbb13723 | 0 | static bool enforce_config_section(void)
{
MachineState *machine = MACHINE(qdev_get_machine());
return machine->enforce_config_section;
}
| 10,053 |
qemu | 01ecaf438b1eb46abe23392c8ce5b7628b0c8cf5 | 0 | MSA_ST_DF(DF_BYTE, b, helper_ret_stb_mmu, oi, GETRA())
MSA_ST_DF(DF_HALF, h, helper_ret_stw_mmu, oi, GETRA())
MSA_ST_DF(DF_WORD, w, helper_ret_stl_mmu, oi, GETRA())
MSA_ST_DF(DF_DOUBLE, d, helper_ret_stq_mmu, oi, GETRA())
#else
MSA_ST_DF(DF_BYTE, b, cpu_stb_data)
MSA_ST_DF(DF_HALF, h, cpu_stw_data)
MSA... | 10,054 |
qemu | 4295e15aa730a95003a3639d6dad2eb1e65a59e2 | 0 | void qemu_spice_add_memslot(SimpleSpiceDisplay *ssd, QXLDevMemSlot *memslot,
qxl_async_io async)
{
if (async != QXL_SYNC) {
#if SPICE_INTERFACE_QXL_MINOR >= 1
spice_qxl_add_memslot_async(&ssd->qxl, memslot, 0);
#else
abort();
#endif
} else {
ssd->wor... | 10,057 |
qemu | 7ebaf7955603cc50988e0eafd5e6074320fefc70 | 0 | static void spapr_cpu_core_register(const SPAPRCoreInfo *info)
{
TypeInfo type_info = {
.parent = TYPE_SPAPR_CPU_CORE,
.instance_size = sizeof(sPAPRCPUCore),
.instance_init = info->initfn,
};
type_info.name = g_strdup_printf("%s-" TYPE_SPAPR_CPU_CORE, info->name);
type_... | 10,058 |
qemu | 9e41bade85ef338afd983c109368d1bbbe931f80 | 0 | static int aer915_init(I2CSlave *i2c)
{
/* Nothing to do. */
return 0;
}
| 10,059 |
qemu | 48eb3ae64b3e17151cf8f42af185e6f43baf707b | 0 | static void define_debug_regs(ARMCPU *cpu)
{
/* Define v7 and v8 architectural debug registers.
* These are just dummy implementations for now.
*/
int i;
define_arm_cp_regs(cpu, debug_cp_reginfo);
if (arm_feature(&cpu->env, ARM_FEATURE_LPAE)) {
define_arm_cp_regs(cpu, debug... | 10,061 |
qemu | 188d857911636fa43628eb8a7beeab4702636317 | 0 | static inline unsigned int rgb_to_pixel8(unsigned int r, unsigned int g, unsigned b)
{
/* XXX: TODO */
return 0;
}
| 10,062 |
qemu | 27a69bb088bee6d4efea254659422fb9c751b3c7 | 0 | static inline void gen_efsneg(DisasContext *ctx)
{
if (unlikely(!ctx->spe_enabled)) {
gen_exception(ctx, POWERPC_EXCP_APU);
return;
}
tcg_gen_xori_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], 0x80000000);
}
| 10,063 |
qemu | 51b19ebe4320f3dcd93cea71235c1219318ddfd2 | 0 | VirtIOBlockReq *virtio_blk_alloc_request(VirtIOBlock *s)
{
VirtIOBlockReq *req = g_new(VirtIOBlockReq, 1);
req->dev = s;
req->qiov.size = 0;
req->in_len = 0;
req->next = NULL;
req->mr_next = NULL;
return req;
}
| 10,065 |
qemu | 891fb2cd4592b6fe76106a69e0ca40efbf82726a | 0 | static void uhci_reset(void *opaque)
{
UHCIState *s = opaque;
uint8_t *pci_conf;
int i;
UHCIPort *port;
DPRINTF("uhci: full reset\n");
pci_conf = s->dev.config;
pci_conf[0x6a] = 0x01; /* usb clock */
pci_conf[0x6b] = 0x00;
s->cmd = 0;
s->status = 0;
s->statu... | 10,066 |
qemu | 786a4ea82ec9c87e3a895cf41081029b285a5fe5 | 0 | static int parse_block_size_shift(BDRVSheepdogState *s, QemuOpts *opt)
{
struct SheepdogInode *inode = &s->inode;
uint64_t object_size;
int obj_order;
object_size = qemu_opt_get_size_del(opt, BLOCK_OPT_OBJECT_SIZE, 0);
if (object_size) {
if ((object_size - 1) & object_size) { /* ... | 10,067 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t mmio_ide_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
MMIOState *s = opaque;
addr >>= s->shift;
if (addr & 7)
return ide_ioport_read(&s->bus, addr);
else
return ide_data_readw(&s->bus, 0);
}
| 10,068 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void dbdma_write(void *opaque, target_phys_addr_t addr,
uint64_t value, unsigned size)
{
int channel = addr >> DBDMA_CHANNEL_SHIFT;
DBDMAState *s = opaque;
DBDMA_channel *ch = &s->channels[channel];
int reg = (addr - (channel << DBDMA_CHANNEL_SHIFT)) >> 2;
DBD... | 10,069 |
qemu | 4a4b88fbe1a95e80a2e29830e69e1deded407fc1 | 0 | static void vfio_iommu_map_notify(IOMMUNotifier *n, IOMMUTLBEntry *iotlb)
{
VFIOGuestIOMMU *giommu = container_of(n, VFIOGuestIOMMU, n);
VFIOContainer *container = giommu->container;
hwaddr iova = iotlb->iova + giommu->iommu_offset;
MemoryRegion *mr;
hwaddr xlat;
hwaddr len = iotlb->addr_... | 10,070 |
FFmpeg | fa0f62c37d90c0760bddccba2054578e2c61ae1a | 0 | static void flush_packet(AVFormatContext *ctx, int stream_index, int last_pkt)
{
MpegMuxContext *s = ctx->priv_data;
StreamInfo *stream = ctx->streams[stream_index]->priv_data;
uint8_t *buf_ptr;
int size, payload_size, startcode, id, len, stuffing_size, i, header_len;
int64_t timestamp;
u... | 10,071 |
FFmpeg | 041086191fc08ab162ad6117b07a5f39639d5d9d | 0 | static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, double *pts_ptr)
{
AVPacket *pkt = &is->audio_pkt;
int n, len1, data_size;
double pts;
for(;;) {
/* NOTE: the audio packet can contain several frames */
while (is->audio_pkt_size > 0) {
len1 = avcodec... | 10,072 |
FFmpeg | f880199375ee661c22128febd531a7faa122ff0f | 0 | static int rtp_write_header(AVFormatContext *s1)
{
RTPDemuxContext *s = s1->priv_data;
int payload_type, max_packet_size, n;
AVStream *st;
if (s1->nb_streams != 1)
return -1;
st = s1->streams[0];
payload_type = rtp_get_payload_type(st->codec);
if (payload_type < 0)
... | 10,073 |
FFmpeg | 5d5de3eba4c7890c2e8077f5b4ae569671d11cf8 | 0 | int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt)
{
V4L2Buffer* avbuf = NULL;
/* if we are draining, we are no longer inputing data, therefore enable a
* timeout so we can dequeue and flag the last valid buffer.
*
* blocks until:
* 1. encoded packet available
... | 10,074 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 0 | static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
const char *stack)
{
VLANClientState *vc;
if (vlan) {
vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);
if (!vc) {
return NULL;
}
if (strcmp... | 10,076 |
qemu | 6a71123469e0c9286354c6655440da51566c1763 | 0 | static void usb_host_speed_compat(USBHostDevice *s)
{
USBDevice *udev = USB_DEVICE(s);
struct libusb_config_descriptor *conf;
const struct libusb_interface_descriptor *intf;
const struct libusb_endpoint_descriptor *endp;
#ifdef HAVE_STREAMS
struct libusb_ss_endpoint_companion_descriptor *endp... | 10,078 |
FFmpeg | af46ca73568ea8edb261d2aeedd892c68fa918bc | 0 | static void find_best_tables(MpegEncContext * s)
{
int i;
int best =-1, best_size =9999999;
int chroma_best=-1, best_chroma_size=9999999;
for(i=0; i<3; i++){
int level;
int chroma_size=0;
int size=0;
if(i>0){// ;)
size++;
... | 10,079 |
qemu | a457e7ee3daeb94b65a1a5a11258bd8b66673269 | 0 | static always_inline void gen_qemu_ld32s(DisasContext *ctx, TCGv arg1, TCGv arg2)
{
if (unlikely(ctx->mem_idx)) {
TCGv_i32 t0;
tcg_gen_qemu_ld32u(arg1, arg2, ctx->mem_idx);
t0 = tcg_temp_new_i32();
tcg_gen_trunc_tl_i32(t0, arg1);
tcg_gen_bswap_i32(t0, t0);
tcg... | 10,080 |
qemu | bd79255d2571a3c68820117caf94ea9afe1d527e | 0 | static inline void gen_ins(DisasContext *s, TCGMemOp ot)
{
if (use_icount)
gen_io_start();
gen_string_movl_A0_EDI(s);
/* Note: we must do this dummy write first to be restartable in
case of page fault. */
tcg_gen_movi_tl(cpu_T[0], 0);
gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
... | 10,082 |
qemu | f3e69beb942103ccd5248273e4d95e76b64ab64c | 0 | void qmp_block_stream(const char *device,
bool has_base, const char *base,
bool has_backing_file, const char *backing_file,
bool has_speed, int64_t speed,
bool has_on_error, BlockdevOnError on_error,
Error... | 10,083 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.