project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
qemu | 5e54769c921a3d8cd8858444f5a3fa62cc44260e | 1 | static void check_suspend_mode(GuestSuspendMode mode, Error **errp)
{
SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
Error *local_err = NULL;
if (error_is_set(errp)) {
return;
}
ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
if (!GetPwrCapabilities(&sys_pwr_caps)) {
error_s... | 23,985 |
qemu | db486cc334aafd3dbdaf107388e37fc3d6d3e171 | 1 | static gint range_compare(gconstpointer a, gconstpointer b)
{
Range *ra = (Range *)a, *rb = (Range *)b;
if (ra->begin == rb->begin && ra->end == rb->end) {
return 0;
} else if (range_get_last(ra->begin, ra->end) <
range_get_last(rb->begin, rb->end)) {
return -1;
} ... | 23,986 |
qemu | 12ac6d3db721a288c8953c5c253230aa0949a0e1 | 1 | static void report_unsupported_feature(BlockDriverState *bs,
Error **errp, Qcow2Feature *table, uint64_t mask)
{
while (table && table->name[0] != '\0') {
if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
if (mask & (1 << table->bit)) {
report_unsupported(bs, errp, "%.... | 23,987 |
qemu | fd28aa132362320f9f3a30b23f634bb14dee528e | 1 | void qemu_ram_free(ram_addr_t addr)
{
RAMBlock *block;
QLIST_FOREACH(block, &ram_list.blocks, next) {
if (addr == block->offset) {
QLIST_REMOVE(block, next);
if (block->flags & RAM_PREALLOC_MASK) {
;
} else if (mem_path) {
#if defined (__lin... | 23,988 |
qemu | ee640c625e190a0c0e6b8966adc0e4720fb75200 | 1 | static int rocker_msix_init(Rocker *r)
{
PCIDevice *dev = PCI_DEVICE(r);
int err;
err = msix_init(dev, ROCKER_MSIX_VEC_COUNT(r->fp_ports),
&r->msix_bar,
ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET,
&r->msix_bar,
... | 23,989 |
FFmpeg | bcd7bf7eeb09a395cc01698842d1b8be9af483fc | 0 | static void avc_wgt_4width_msa(uint8_t *data,
int32_t stride,
int32_t height,
int32_t log2_denom,
int32_t src_weight,
int32_t offset_in)
{
if (2 == height... | 23,990 |
FFmpeg | d3e5fbb1406995e07fccbff3ca8c1e24f57a1f7b | 0 | static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
int32_t *data, int count, int order, int fracbits)
{
int res;
int absres;
while (count--) {
/* round fixedpoint scalar product */
res = ctx->adsp.scalarproduct_and_madd_int16(f->coeff... | 23,991 |
FFmpeg | 78baa450d9939957f52d5187beb95d763d2f1f18 | 1 | static int ffm2_read_header(AVFormatContext *s)
{
FFMContext *ffm = s->priv_data;
AVStream *st;
AVIOContext *pb = s->pb;
AVCodecContext *codec;
const AVCodecDescriptor *codec_desc;
int ret, i;
int f_main = 0, f_cprv = -1, f_stvi = -1, f_stau = -1;
AVCodec *enc;
char *buffer... | 23,992 |
FFmpeg | 12c3e120fe8f8d6881001eade390d8a5c185783d | 1 | static int h263p_decode_umotion(MpegEncContext * s, int pred)
{
int code = 0, sign;
if (get_bits1(&s->gb)) /* Motion difference = 0 */
return pred;
code = 2 + get_bits1(&s->gb);
while (get_bits1(&s->gb))
{
code <<= 1;
code += get_bits1(&s->gb);
if (code >= 32768) {... | 23,993 |
FFmpeg | 68aefbe81cb3b9dd002108782bb8d798e1c12806 | 1 | static void stream_pause(VideoState *is)
{
is->paused = !is->paused;
if (!is->paused) {
if(is->read_pause_return != AVERROR(ENOSYS)){
is->video_current_pts = get_video_clock(is);
}
is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0;
i... | 23,994 |
qemu | 1c7336c5d1f720e8d320cb36f9d747ad24663e0d | 1 | static void gen_tlbia(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
gen_helper_tlbia(cpu_env);
#endif
}
| 23,995 |
FFmpeg | 19000122a4cc7551cef19ccc6ce4db82d7d290bd | 1 | int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pic_arg, int *got_packet)
{
MpegEncContext *s = avctx->priv_data;
int i, stuffing_count, ret;
int context_count = s->slice_context_count;
s->picture_in_gop_number++;
if (load_input_pic... | 23,996 |
FFmpeg | ae4cffd9fc5bc495692920d646d7d1462315cfa6 | 0 | static inline void RENAME(rgb32tobgr15)(const uint8_t *src, uint8_t *dst, unsigned src_size)
{
const uint8_t *s = src;
const uint8_t *end;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
#ifdef HAVE_MMX
__asm __volatile(PREFETCH" %0"::"m"(*src):"memory");... | 23,997 |
FFmpeg | 8eeacf31c5ea37baf6b222dc38d20cf4fd33c455 | 0 | static void FUNC(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,
ptrdiff_t _ystride, int *_tc,
uint8_t *_no_p, uint8_t *_no_q)
{
int d, j, no_p, no_q;
pixel *pix = (pixel *)_pix;
ptrdiff_t xstride = ... | 23,998 |
FFmpeg | 4e987f8282ff7658a6f804b9db39954bb59fa72e | 0 | static inline void xchg_mb_border(H264Context *h, uint8_t *src_y,
uint8_t *src_cb, uint8_t *src_cr,
int linesize, int uvlinesize,
int xchg, int simple, int pixel_shift){
MpegEncContext * const s = &h->s;
i... | 23,999 |
FFmpeg | f1783c05f1398b7a08f16f6aafbcf38a5323e770 | 0 | static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
AVPacket *avpkt)
{
int ret;
HEVCContext *s = avctx->priv_data;
if (!avpkt->size) {
ret = ff_hevc_output_frame(s, data, 1);
if (ret < 0)
return ret;
*... | 24,000 |
qemu | cdd346371e09709be8e46398bb097dc690a746f2 | 1 | static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
{
uint32_t dw10 = le32_to_cpu(cmd->cdw10);
uint32_t result;
switch (dw10) {
case NVME_VOLATILE_WRITE_CACHE:
result = blk_enable_write_cache(n->conf.blk);
break;
case NVME_NUMBER_OF_QUEUES:
... | 24,001 |
FFmpeg | 03616af2c91309d58f9419becf45d292cb93e625 | 1 | static int decode_subframe(TAKDecContext *s, int32_t *decoded,
int subframe_size, int prev_subframe_size)
{
GetBitContext *gb = &s->gb;
int x, y, i, j, ret = 0;
int dshift, size, filter_quant, filter_order, filter_order16;
int tfilter[MAX_PREDICTORS];
if (!get_bit... | 24,002 |
qemu | 1da45e0c4cf4719fa75898d019e0874b9b2bc774 | 1 | iscsi_allocmap_update(IscsiLun *iscsilun, int64_t sector_num,
int nb_sectors, bool allocated, bool valid)
{
int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk;
if (iscsilun->allocmap == NULL) {
return;
}
/* expand to entirely contain all affecte... | 24,003 |
FFmpeg | 4a24837e07c4782658d1475b77506bccc3d0b5e2 | 1 | static int dca_decode_frame(AVCodecContext * avctx,
void *data, int *data_size,
const uint8_t * buf, int buf_size)
{
int i, j, k;
int16_t *samples = data;
DCAContext *s = avctx->priv_data;
int channels;
s->dca_buffer_size = dca_co... | 24,004 |
FFmpeg | 229843aa359ae0c9519977d7fa952688db63f559 | 0 | static int teletext_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
{
TeletextContext *ctx = avctx->priv_data;
AVSubtitle *sub = data;
int ret = 0;
if (!ctx->vbi) {
if (!(ctx->vbi = vbi_decoder_new()))
return AVERROR(ENOMEM);
... | 24,005 |
qemu | 9604f70fdf8e21ec0dbf6eac5e59a0eb8beadd64 | 1 | static void pc_init_pci_1_5(QEMUMachineInitArgs *args)
{
has_pci_info = false;
pc_init_pci(args);
}
| 24,006 |
qemu | 278412d0e710e2e848c6e510f8308e5b1ed4d03e | 1 | static int usbnet_can_receive(NetClientState *nc)
{
USBNetState *s = qemu_get_nic_opaque(nc);
if (is_rndis(s) && s->rndis_state != RNDIS_DATA_INITIALIZED) {
return 1;
return !s->in_len; | 24,007 |
FFmpeg | c341f734e5f9d6af4a8fdcceb6f5d12de6395c76 | 1 | static inline int hpel_motion_lowres(MpegEncContext *s,
uint8_t *dest, uint8_t *src,
int field_based, int field_select,
int src_x, int src_y,
int width, int height, int... | 24,008 |
qemu | ccbcfedd17fd2d13521fcee66810d0df464ec1cc | 1 | int qemu_devtree_add_subnode(void *fdt, const char *name)
{
int offset;
char *dupname = g_strdup(name);
char *basename = strrchr(dupname, '/');
int retval;
if (!basename) {
return -1;
}
basename[0] = '\0';
basename++;
offset = fdt_path_offset(fdt, dupname);
... | 24,010 |
FFmpeg | 2f7a12fab5a2ea17bd78b155e9af965669fb9b52 | 1 | av_cold void ff_mlz_init_dict(void* context, MLZ *mlz) {
mlz->dict = av_malloc_array(TABLE_SIZE, sizeof(*mlz->dict));
mlz->flush_code = FLUSH_CODE;
mlz->current_dic_index_max = DIC_INDEX_INIT;
mlz->dic_code_bit = CODE_BIT_INIT;
mlz->bump_code = (DIC_INDEX_INIT ... | 24,011 |
FFmpeg | 4f5eaf0b5956e492ee5023929669b1d09aaf6299 | 1 | static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,
uint16_t *dst, int dst_stride,
const uint8_t *buf, unsigned buf_size,
const int16_t *qmat, int log2_blocks_per_mb)
{
ProresContext *ctx = avctx... | 24,012 |
FFmpeg | 7684a36113fa12c88ba80b5498f05849a6b58632 | 0 | static int mxf_write_footer(AVFormatContext *s)
{
MXFContext *mxf = s->priv_data;
AVIOContext *pb = s->pb;
mxf->duration = mxf->last_indexed_edit_unit + mxf->edit_units_count;
mxf_write_klv_fill(s);
mxf->footer_partition_offset = avio_tell(pb);
if (mxf->edit_unit_byte_count) { // no n... | 24,014 |
qemu | f3c7d0389fe8a2792fd4c1cf151b885de03c8f62 | 1 | static void pxa2xx_pcmcia_initfn(Object *obj)
{
SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(obj);
memory_region_init(&s->container_mem, obj, "container", 0x10000000);
sysbus_init_mmio(sbd, &s->container_mem);
/* Socket I/O Memory Space */
memory_regio... | 24,015 |
qemu | 7cfd527525a7d6b1c904890a6b84c1227846415e | 1 | static int mirror_cow_align(MirrorBlockJob *s, int64_t *offset,
uint64_t *bytes)
{
bool need_cow;
int ret = 0;
int64_t align_offset = *offset;
unsigned int align_bytes = *bytes;
int max_bytes = s->granularity * s->max_iov;
assert(*bytes < INT_MAX);
need... | 24,016 |
qemu | 44b6789299a8acca3f25331bc411055cafc7bb06 | 1 | static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB *acb,
const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "blkverify: %s sector_num=%" PRId64 " nb_sectors=%d ",
acb->is_write ? "write" : "read", acb->sector_num,
... | 24,017 |
FFmpeg | 98308bd44face14ea3142b501d16226eec23b75a | 0 | static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MatroskaMuxContext *mkv = s->priv_data;
int codec_type = s->streams[pkt->stream_index]->codec->codec_type;
int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
int cluster_size;
int cluster_size_limit;
int64_... | 24,019 |
FFmpeg | 7495c3066d7b67bbc74b1d5565684ff48e430099 | 0 | static int64_t getutime(void)
{
#ifdef HAVE_GETRUSAGE
struct rusage rusage;
getrusage(RUSAGE_SELF, &rusage);
return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
#elif defined(__MINGW32__)
return av_gettime();
#endif
}
| 24,020 |
FFmpeg | 061e340c05bde91ac988677e47bc562b04be5c20 | 0 | static void colored_fputs(int level, const char *str)
{
if (!*str)
return;
if (use_color < 0) {
#if HAVE_SETCONSOLETEXTATTRIBUTE
CONSOLE_SCREEN_BUFFER_INFO con_info;
con = GetStdHandle(STD_ERROR_HANDLE);
use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") &... | 24,021 |
qemu | be93f216278d84d283187c95cef16c0b60b711b8 | 1 | static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask)
{
int i, count, err;
struct pollfd *pfds;
count = snd_pcm_poll_descriptors_count (handle);
if (count <= 0) {
dolog ("Could not initialize poll mode\n"
"Invalid number of poll descriptors %d\n",... | 24,022 |
FFmpeg | cc276c85d15272df6e44fb3252657a43cbd49555 | 0 | AVFilterBufferRef *avfilter_default_get_audio_buffer(AVFilterLink *link, int perms,
enum AVSampleFormat sample_fmt, int size,
int64_t channel_layout, int planar)
{
AVFilterBuffer *samples = av_mallocz(sizeo... | 24,023 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | static MigrationState *migrate_init(const MigrationParams *params)
{
MigrationState *s = migrate_get_current();
int64_t bandwidth_limit = s->bandwidth_limit;
bool enabled_capabilities[MIGRATION_CAPABILITY_MAX];
int64_t xbzrle_cache_size = s->xbzrle_cache_size;
memcpy(enabled_capabilities, s-... | 24,024 |
qemu | 5d443f5adad6ddd8238602990b7e86404a288d48 | 1 | static void chr_read(void *opaque, const uint8_t *buf, int size)
{
TestServer *s = opaque;
CharDriverState *chr = s->chr;
VhostUserMsg msg;
uint8_t *p = (uint8_t *) &msg;
int fd;
if (size != VHOST_USER_HDR_SIZE) {
g_test_message("Wrong message size received %d\n", size);
return;
... | 24,025 |
FFmpeg | 3d5822d9cf07d08bce82903e4715658f46b01b5c | 1 | static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int precno,
uint8_t *expn, int numgbits)
{
int bandno, empty = 1;
// init bitstream
*s->buf = 0;
s->bit_index = 0;
// header
// is the packet empty?
for (bandno = 0; bandno ... | 24,026 |
FFmpeg | d164ad3298c155330e303bea907920643b5d74a3 | 1 | static int ivi_init_tiles(IVIBandDesc *band, IVITile *ref_tile,
int p, int b, int t_height, int t_width)
{
int x, y;
IVITile *tile = band->tiles;
for (y = 0; y < band->height; y += t_height) {
for (x = 0; x < band->width; x += t_width) {
tile->xpos ... | 24,027 |
FFmpeg | a0e7079a207fc38cb3754cf11a29863c81f633e4 | 1 | static av_cold int common_end(AVCodecContext *avctx){
FFV1Context *s = avctx->priv_data;
int i, j;
for(j=0; j<s->slice_count; j++){
FFV1Context *fs= s->slice_context[j];
for(i=0; i<s->plane_count; i++){
PlaneContext *p= &fs->plane[i];
av_freep(&p->state);
... | 24,028 |
FFmpeg | be630b1e08ebe8f766b1798accd6b8e5e096f5aa | 1 | unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx,
const AVDXVAContext *ctx,
const AVFrame *frame)
{
void *surface = ff_dxva2_get_surface(frame);
unsigned i;
for (i = 0; i < DXVA_CONTEXT_COUNT(avctx, ctx); i++)
... | 24,029 |
qemu | afed5a5a7030a074a181d2a0ce8202de71a6ada4 | 1 | CpuInfoList *qmp_query_cpus(Error **errp)
{
MachineState *ms = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(ms);
CpuInfoList *head = NULL, *cur_item = NULL;
CPUState *cpu;
CPU_FOREACH(cpu) {
CpuInfoList *info;
#if defined(TARGET_I386)
X86CPU *x86_cpu =... | 24,030 |
qemu | 073de86aa934d46d596a2367e7501da5500e5b86 | 1 | static hwaddr ppc_hash64_htab_lookup(PowerPCCPU *cpu,
ppc_slb_t *slb, target_ulong eaddr,
ppc_hash_pte64_t *pte)
{
CPUPPCState *env = &cpu->env;
hwaddr pte_offset;
hwaddr hash;
uint64_t vsid, epnmask, epn, ptem;
/* T... | 24,031 |
qemu | ec6469a3b1da26247bdb3f5dd5276fabcc1b694a | 1 | static always_inline void gen_op_neg (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check)
{
int l1, l2;
l1 = gen_new_label();
l2 = gen_new_label();
#if defined(TARGET_PPC64)
if (ctx->sf_mode) {
tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT64_MIN, l1);
} else {
TCGv t0 = tcg_... | 24,032 |
qemu | 007cd223de527b5f41278f2d886c1a4beb3e67aa | 1 | static int tx_consume(Rocker *r, DescInfo *info)
{
PCIDevice *dev = PCI_DEVICE(r);
char *buf = desc_get_buf(info, true);
RockerTlv *tlv_frag;
RockerTlv *tlvs[ROCKER_TLV_TX_MAX + 1];
struct iovec iov[ROCKER_TX_FRAGS_MAX] = { { 0, }, };
uint32_t pport;
uint32_t port;
uint16_t tx_o... | 24,033 |
qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 | 1 | static void gen_neon_dup_low16(TCGv var)
{
TCGv tmp = new_tmp();
tcg_gen_ext16u_i32(var, var);
tcg_gen_shli_i32(tmp, var, 16);
tcg_gen_or_i32(var, var, tmp);
dead_tmp(tmp);
}
| 24,034 |
qemu | 1ea879e5580f63414693655fcf0328559cdce138 | 0 | static void audio_print_settings (audsettings_t *as)
{
dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels);
switch (as->fmt) {
case AUD_FMT_S8:
AUD_log (NULL, "S8");
break;
case AUD_FMT_U8:
AUD_log (NULL, "U8");
break;
case AUD_FMT_S16:
... | 24,035 |
qemu | 7bd427d801e1e3293a634d3c83beadaa90ffb911 | 0 | static void vnc_refresh(void *opaque)
{
VncDisplay *vd = opaque;
VncState *vs, *vn;
int has_dirty, rects = 0;
vga_hw_update();
if (vnc_trylock_display(vd)) {
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) +
... | 24,036 |
qemu | d4d34b0d3f5af5c8e09980da0de2eebe9a27dc71 | 0 | static void set_pointer(Object *obj, Visitor *v, Property *prop,
int (*parse)(DeviceState *dev, const char *str, void **ptr),
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Error *local_err = NULL;
void **ptr = qdev_get_prop_ptr(dev, p... | 24,038 |
qemu | a818a4b69d47ca3826dee36878074395aeac2083 | 0 | static int scsi_hd_initfn(SCSIDevice *dev)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
s->qdev.blocksize = s->qdev.conf.logical_block_size;
s->qdev.type = TYPE_DISK;
if (!s->product) {
s->product = g_strdup("QEMU HARDDISK");
}
return scsi_initfn(&s->qdev);
}
| 24,039 |
qemu | 2c30dd744aa02d31a8a3b87daaba0b2cb774f346 | 0 | static int local_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse)
{
const char *sec_model = qemu_opt_get(opts, "security_model");
const char *path = qemu_opt_get(opts, "path");
if (!sec_model) {
fprintf(stderr, "security model not specified, "
"local fs needs security mo... | 24,040 |
qemu | e1833e1f96456fd8fc17463246fe0b2050e68efb | 0 | static void spr_write_dbatl_h (void *opaque, int sprn)
{
DisasContext *ctx = opaque;
gen_op_store_dbatl((sprn - SPR_DBAT4L) / 2);
RET_STOP(ctx);
}
| 24,041 |
qemu | 548f66db33b91bf305c4e5228bb29585701ab58d | 0 | static void do_branch_reg(DisasContext *dc, int32_t offset, uint32_t insn,
TCGv r_cond, TCGv r_reg)
{
unsigned int cond = GET_FIELD_SP(insn, 25, 27), a = (insn & (1 << 29));
target_ulong target = dc->pc + offset;
flush_cond(dc, r_cond);
gen_cond_reg(r_cond, cond, r_reg)... | 24,043 |
qemu | a9321a4d49d65d29c2926a51aedc5b91a01f3591 | 0 | static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
{
int b, prefixes, aflag, dflag;
int shift, ot;
int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
target_ulong next_eip, tval;
int rex_w, rex_r;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_T... | 24,045 |
FFmpeg | 3819db745da2ac7fb3faacb116788c32f4753f34 | 0 | static void rpza_decode_stream(RpzaContext *s)
{
int width = s->avctx->width;
int stride = s->frame.linesize[0] / 2;
int row_inc = stride - 4;
int stream_ptr = 0;
int chunk_size;
unsigned char opcode;
int n_blocks;
unsigned short colorA = 0, colorB;
unsigned short color4[4]... | 24,049 |
qemu | 891fb2cd4592b6fe76106a69e0ca40efbf82726a | 0 | int usb_device_attach(USBDevice *dev)
{
USBBus *bus = usb_bus_from_device(dev);
if (bus->nfree == 1 && dev->port_path == NULL) {
/* Create a new hub and chain it on
(unless a physical port location is specified). */
usb_create_simple(bus, "usb-hub");
}
return do_atta... | 24,051 |
qemu | 83f338f73ecb88cc6f85d6e7b81ebef112ce07be | 0 | static void cpu_debug_handler(CPUState *env)
{
gdb_set_stop_cpu(env);
qemu_system_debug_request();
}
| 24,052 |
qemu | 8360544a6d3a54df1fce80f55ba4ad075a8ded54 | 0 | static uint16_t qpci_spapr_io_readw(QPCIBus *bus, void *addr)
{
QPCIBusSPAPR *s = container_of(bus, QPCIBusSPAPR, bus);
uint64_t port = (uintptr_t)addr;
uint16_t v;
if (port < s->pio.size) {
v = readw(s->pio_cpu_base + port);
} else {
v = readw(s->mmio_cpu_base + port);
... | 24,054 |
FFmpeg | d0a503c97cc59b17e77585a726448dfa46245f4d | 0 | static int ast_read_header(AVFormatContext *s)
{
int codec;
AVStream *st;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
avio_skip(s->pb, 8);
codec = avio_rb16(s->pb);
switch (codec) {
case 1:
st->codec->codec_id = AV_CODEC_ID_PCM_S16BE... | 24,055 |
FFmpeg | e48ded8551172b58a78f30303a81dfce125344e0 | 0 | static av_cold int vsink_init(AVFilterContext *ctx, void *opaque)
{
BufferSinkContext *buf = ctx->priv;
AVBufferSinkParams *params = opaque;
if (params && params->pixel_fmts) {
const int *pixel_fmts = params->pixel_fmts;
buf->pixel_fmts = ff_copy_int_list(pixel_fmts);
if (... | 24,056 |
FFmpeg | 7f46a641bf2540b8cf1293d5e50c0c0e34264254 | 1 | static int aac_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AACContext *ac = avctx->priv_data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
GetBitContext gb;
int buf_consumed;
int buf_offset;
int ... | 24,057 |
qemu | f03a1af581b926118d619ad1acc3304ad84d5e5b | 1 | static void init_proc_book3s_64(CPUPPCState *env, int version)
{
gen_spr_ne_601(env);
gen_tbl(env);
gen_spr_book3s_altivec(env);
gen_spr_book3s_pmu_sup(env);
gen_spr_book3s_pmu_user(env);
gen_spr_book3s_common(env);
switch (version) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_... | 24,058 |
qemu | c6047e9621f77a65993bcda8f58b676996e24bb5 | 1 | static void virtio_host_initfn(Object *obj)
{
VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(obj);
virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
TYPE_VIRTIO_INPUT_HOST);
}
| 24,059 |
qemu | c2b6ff51e4a3ad1f7ec5dbc94970e9778b31d718 | 1 | int qcow2_update_snapshot_refcount(BlockDriverState *bs,
int64_t l1_table_offset, int l1_size, int addend)
{
BDRVQcowState *s = bs->opaque;
uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2, l1_allocated;
int64_t old_offset, old_l2_offset;
int i, j, l1_modified = 0, nb_csectors, refco... | 24,060 |
FFmpeg | c595139f1fdb5ce5ee128c317ed9e4e836282436 | 1 | int ff_dirac_golomb_read_32bit(DiracGolombLUT *lut_ctx, const uint8_t *buf,
int bytes, uint8_t *_dst, int coeffs)
{
int i, b, c_idx = 0;
int32_t *dst = (int32_t *)_dst;
DiracGolombLUT *future[4], *l = &lut_ctx[2*LUT_SIZE + buf[0]];
INIT_RESIDUE(res);
for (b = 1; b <= b... | 24,061 |
qemu | 6d74ca5aa83b83fb52332f7735c61ecb7a5328c1 | 1 | static uint32_t syborg_virtio_readl(void *opaque, target_phys_addr_t offset)
{
SyborgVirtIOProxy *s = opaque;
VirtIODevice *vdev = s->vdev;
uint32_t ret;
DPRINTF("readl 0x%x\n", (int)offset);
if (offset >= SYBORG_VIRTIO_CONFIG) {
return virtio_config_readl(vdev, offset - SYBORG_VIRT... | 24,062 |
qemu | 07555ba6f303d4be8af538c3a66cc46ccb2e5751 | 1 | static int nfs_file_create(const char *url, QemuOpts *opts, Error **errp)
{
int ret = 0;
int64_t total_size = 0;
NFSClient *client = g_new0(NFSClient, 1);
QDict *options = NULL;
client->aio_context = qemu_get_aio_context();
/* Read out options */
total_size = ROUND_UP(qemu_opt_ge... | 24,064 |
qemu | 91a9ecefb6d7f066c6eecc09f7231ce7969d1817 | 1 | int setenv(const char *name, const char *value, int overwrite)
{
int result = 0;
if (overwrite || !getenv(name)) {
size_t length = strlen(name) + strlen(value) + 2;
char *string = g_malloc(length);
snprintf(string, length, "%s=%s", name, value);
result = putenv(string);
}
... | 24,065 |
FFmpeg | 50c21814b9de5635cf01e2d1ea091a9a272a4d67 | 1 | static void clone_tables(H264Context *dst, H264Context *src){
dst->intra4x4_pred_mode = src->intra4x4_pred_mode;
dst->non_zero_count = src->non_zero_count;
dst->slice_table = src->slice_table;
dst->cbp_table = src->cbp_table;
dst->mb2b_xy ... | 24,067 |
qemu | 77cb0f5aafc8e6d0c6d3c339f381c9b7921648e0 | 1 | static void adb_kbd_reset(DeviceState *dev)
{
ADBDevice *d = ADB_DEVICE(dev);
KBDState *s = ADB_KEYBOARD(dev);
d->handler = 1;
d->devaddr = ADB_DEVID_KEYBOARD;
memset(s->data, 0, sizeof(s->data));
s->rptr = 0;
s->wptr = 0;
s->count = 0;
}
| 24,068 |
FFmpeg | 76cd98b445c5a1608e9a5974bef0b0be6b35f1ce | 1 | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al,
const uint8_t *mb_bitmask, const AVFrame *reference){
int i, mb_x, mb_y;
uint8_t* data[MAX_COMPONENTS];
const uint8_t *reference_data[MAX_COMPONENTS];
int linesize[MAX_COMPONENTS];
... | 24,071 |
FFmpeg | 629b2ed0ac77d7c4bf1aeac5e70cafee5fa0fcae | 0 | static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
int64_t dts, int64_t next)
{
AVIOContext *pb = s->pb;
AVStream *st = NULL;
char buf[20];
int ret = AVERROR_INVALIDDATA;
int i, length = -1;
switch (avio_r8(pb)) {
case AMF_DATA_TYPE_MIXEDAR... | 24,073 |
FFmpeg | 3b7ebeb4d52a25c7e1038ae90c6c19b0d6f11877 | 0 | void ff_h264_write_back_intra_pred_mode(H264Context *h){
int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];
AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);
mode[4]= h->intra4x4_pred_mode_cache[7+8*3];
mode[5]= h->intra4x4_pred_mode_cache[7+8*2];
mode[6]= h->intra4x4_pred_mod... | 24,074 |
FFmpeg | 93ef29b6f47eda7d73eb9e71628f1f1abb64266d | 1 | static int noise(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size, int keyframe){
unsigned int *state= bsfc->priv_data;
int amount= args ? atoi(args) : (*state % 10001+1);
... | 24,076 |
FFmpeg | e268a352af893e47bd3ea2aed90761cb0b4feca7 | 0 | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al,
const uint8_t *mb_bitmask, const AVFrame *reference){
int i, mb_x, mb_y;
uint8_t* data[MAX_COMPONENTS];
const uint8_t *reference_data[MAX_COMPONENTS];
int linesize[MAX_COMPONENTS];
... | 24,077 |
qemu | 3456a8d1852e970688b73d03fdc44dde851759e1 | 1 | static void qcow2_invalidate_cache(BlockDriverState *bs)
{
BDRVQcowState *s = bs->opaque;
int flags = s->flags;
AES_KEY aes_encrypt_key;
AES_KEY aes_decrypt_key;
uint32_t crypt_method = 0;
QDict *options;
/*
* Backing files are read-only which makes all of their metadata immutable,
... | 24,078 |
FFmpeg | e29153f414f5b2d10e0386abf7921aed4a4fa454 | 1 | static av_cold int avui_encode_init(AVCodecContext *avctx)
{
avctx->coded_frame = av_frame_alloc();
if (avctx->width != 720 || avctx->height != 486 && avctx->height != 576) {
av_log(avctx, AV_LOG_ERROR, "Only 720x486 and 720x576 are supported.\n");
return AVERROR(EINVAL);
}
if (... | 24,079 |
qemu | 2886be1b01c274570fa139748a402207482405bd | 1 | void acpi_pm1_evt_write_sts(ACPIREGS *ar, uint16_t val)
{
uint16_t pm1_sts = acpi_pm1_evt_get_sts(ar, ar->tmr.overflow_time);
if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) {
/* if TMRSTS is reset, then compute the new overflow time */
acpi_pm_tmr_calc_overflow_time(ar);
}
ar->pm1... | 24,080 |
FFmpeg | 955aec3c7c7be39b659197e1ec379a09f2b7c41c | 0 | static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MPADecodeContext *s = avctx->priv_data;
uint32_t header;
int ret;
if (buf_size < HEADER_SIZE)... | 24,081 |
FFmpeg | fde1bc64adbec49301c665efab2b49b94bb39c23 | 0 | int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
{
int ret = 0;
AVDictionary *tmp = NULL;
if (avcodec_is_open(avctx))
return 0;
if ((!codec && !avctx->codec)) {
av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2(... | 24,082 |
FFmpeg | 486637af8ef29ec215e0e0b7ecd3b5470f0e04e5 | 0 | static int get_transform_coeffs1(uint8_t *exps, uint8_t *bap, float chcoeff,
float *coeffs, int start, int end, int dith_flag, GetBitContext *gb,
dither_state *state)
{
int16_t mantissa;
int i;
int gcode;
mant_group l3_grp, l5_grp, l11_grp;
for (i = 0; i < 3; i++)
... | 24,083 |
qemu | 1f3870ab242018b724b845957f7f928a2d7c1f5b | 0 | static int usb_host_update_interfaces(USBHostDevice *dev, int configuration)
{
int dev_descr_len, config_descr_len;
int interface, nb_interfaces, nb_configurations;
int ret, i;
if (configuration == 0) /* address state - ignore */
return 1;
i = 0;
dev_descr_len = dev->descr[0]... | 24,086 |
qemu | 237d78f8fc62e62f62246883ecf62e44ed35fb80 | 0 | static int get_block_status(BlockDriverState *bs, int64_t offset,
int64_t bytes, MapEntry *e)
{
int64_t ret;
int depth;
BlockDriverState *file;
bool has_offset;
int nb_sectors = bytes >> BDRV_SECTOR_BITS;
assert(bytes < INT_MAX);
/* As an optimization, ... | 24,088 |
qemu | dd321ecfc2e82e6f9578b986060b1aa3f036bd98 | 0 | static void *colo_compare_thread(void *opaque)
{
CompareState *s = opaque;
GSource *timeout_source;
s->worker_context = g_main_context_new();
qemu_chr_fe_set_handlers(&s->chr_pri_in, compare_chr_can_read,
compare_pri_chr_in, NULL, NULL,
... | 24,091 |
qemu | b192af8acc597a6e8068873434e56e0c7de1b7d3 | 0 | static int find_image_format(BlockDriverState *bs, const char *filename,
BlockDriver **pdrv, Error **errp)
{
BlockDriver *drv;
uint8_t buf[BLOCK_PROBE_BUF_SIZE];
int ret = 0;
/* Return the raw BlockDriver * to scsi-generic devices or empty drives */
if (bs->sg |... | 24,092 |
FFmpeg | 284b432662b6e137148ff9d13ef2b554cb14b4ae | 0 | static int fits_write_packet(AVFormatContext *s, AVPacket *pkt)
{
write_image_header(s);
avio_write(s->pb, pkt->data, pkt->size);
return 0;
}
| 24,093 |
qemu | af52fe862fba686713044efdf9158195f84535ab | 0 | static void uart_parameters_setup(UartState *s)
{
QEMUSerialSetParams ssp;
unsigned int baud_rate, packet_size;
baud_rate = (s->r[R_MR] & UART_MR_CLKS) ?
UART_INPUT_CLK / 8 : UART_INPUT_CLK;
ssp.speed = baud_rate / (s->r[R_BRGR] * (s->r[R_BDIV] + 1));
packet_size = 1;
s... | 24,094 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | eth_read(void *opaque, target_phys_addr_t addr, unsigned int size)
{
struct fs_eth *eth = opaque;
uint32_t r = 0;
addr >>= 2;
switch (addr) {
case R_STAT:
r = eth->mdio_bus.mdio & 1;
break;
default:
r = eth->regs[addr];
D(printf ("%s %x\n", __func__, addr * 4));
break;
}
return r;... | 24,096 |
qemu | be3512610bdeebfaa40c63ae15d19d9fae991e1b | 0 | int vnc_display_open(DisplayState *ds, const char *display)
{
VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
const char *options;
int password = 0;
int reverse = 0;
int to_port = 0;
#ifdef CONFIG_VNC_TLS
int tls = 0, x509 = 0;
#endif
vnc_display_close(ds);
if (strcm... | 24,097 |
qemu | 10ee2aaa417d8d8978cdb2bbed55ebb152df5f6b | 0 | static void nabm_writeb (void *opaque, uint32_t addr, uint32_t val)
{
PCIAC97LinkState *d = opaque;
AC97LinkState *s = &d->ac97;
AC97BusMasterRegs *r = NULL;
uint32_t index = addr - s->base[1];
switch (index) {
case PI_LVI:
case PO_LVI:
case MC_LVI:
r = &s->bm_regs[GET_... | 24,098 |
qemu | a8d411abac9347aadeac87687b8a3c9895ea0fd7 | 0 | void helper_xssubqp(CPUPPCState *env, uint32_t opcode)
{
ppc_vsr_t xt, xa, xb;
float_status tstat;
getVSR(rA(opcode) + 32, &xa, env);
getVSR(rB(opcode) + 32, &xb, env);
getVSR(rD(opcode) + 32, &xt, env);
helper_reset_fpstatus(env);
if (unlikely(Rc(opcode) != 0)) {
/* TOD... | 24,099 |
qemu | 560e63965232e37d1916a447125cf91c18a96930 | 0 | void acpi_pm1_cnt_init(ACPIREGS *ar, MemoryRegion *parent)
{
ar->wakeup.notify = acpi_notify_wakeup;
qemu_register_wakeup_notifier(&ar->wakeup);
memory_region_init_io(&ar->pm1.cnt.io, &acpi_pm_cnt_ops, ar, "acpi-cnt", 2);
memory_region_add_subregion(parent, 4, &ar->pm1.cnt.io);
}
| 24,101 |
qemu | f5793fd9e1fd89808f4adbfe690235b094176a37 | 0 | static void vfio_probe_nvidia_bar0_quirk(VFIOPCIDevice *vdev, int nr)
{
VFIOQuirk *quirk;
VFIOConfigMirrorQuirk *mirror;
if (!vfio_pci_is(vdev, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) ||
!vfio_is_vga(vdev) || nr != 0) {
return;
}
quirk = g_malloc0(sizeof(*quirk));
mirror =... | 24,102 |
FFmpeg | eabbc64728c2fdb74f565aededec2ab023d20699 | 0 | static int mkv_write_tag_targets(AVFormatContext *s,
unsigned int elementid, unsigned int uid,
ebml_master *tags, ebml_master* tag)
{
AVIOContext *pb;
MatroskaMuxContext *mkv = s->priv_data;
ebml_master targets;
int ret;
if ... | 24,104 |
qemu | 364031f17932814484657e5551ba12957d993d7e | 0 | static int v9fs_synth_symlink(FsContext *fs_ctx, const char *oldpath,
V9fsPath *newpath, const char *buf, FsCred *credp)
{
errno = EPERM;
return -1;
}
| 24,105 |
qemu | 8eca6b1bc770982595db2f7207c65051572436cb | 0 | static uint32_t virtio_ioport_read(void *opaque, uint32_t addr)
{
VirtIODevice *vdev = to_virtio_device(opaque);
uint32_t ret = 0xFFFFFFFF;
addr -= vdev->addr;
switch (addr) {
case VIRTIO_PCI_HOST_FEATURES:
ret = vdev->get_features(vdev);
ret |= (1 << VIRTIO_F_NOTIFY_ON_E... | 24,106 |
qemu | e305a16510afa74eec20390479e349402e55ef4c | 1 | static void sb16_realizefn (DeviceState *dev, Error **errp)
{
ISADevice *isadev = ISA_DEVICE (dev);
SB16State *s = SB16 (dev);
IsaDmaClass *k;
isa_init_irq (isadev, &s->pic, s->irq);
s->mixer_regs[0x80] = magic_of_irq (s->irq);
s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma);
... | 24,107 |
qemu | 0e1cd6576c55269b6e5251dc739a7fc819f9b4a6 | 1 | static int slavio_misc_init1(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
MiscState *s = SLAVIO_MISC(dev);
sysbus_init_irq(sbd, &s->irq);
sysbus_init_irq(sbd, &s->fdc_tc);
/* 8 bit registers */
/* Slavio control */
memory_region_init_io(&s->cfg_iomem, OBJECT(s), &slavio_c... | 24,108 |
qemu | cc1e13913916f755fd2dc5041b8d4bf25d3ea88e | 1 | static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr,
Error **errp)
{
QIOChannelSocket *sioc;
Error *local_err = NULL;
sioc = qio_channel_socket_new();
qio_channel_set_name(QIO_CHANNEL(sioc), "nbd-client");
qio_channel_so... | 24,109 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.