project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
qemu | 5bbf90be97203c472f47da070c0040b464c0460f | 0 | static void memory_region_dispatch_write(MemoryRegion *mr,
hwaddr addr,
uint64_t data,
unsigned size)
{
if (!memory_region_access_valid(mr, addr, size, true)) {
return; /* FIXME: ... | 25,015 |
qemu | 49aa46bb4b894ff8bdb0339ee2a5dd3fcfe93ecd | 0 | int bdrv_eject(BlockDriverState *bs, int eject_flag)
{
BlockDriver *drv = bs->drv;
if (bs->locked) {
return -EBUSY;
}
if (drv && drv->bdrv_eject) {
drv->bdrv_eject(bs, eject_flag);
}
bs->tray_open = eject_flag;
return 0;
}
| 25,016 |
qemu | a2db2a1edd06a50b8a862c654cf993368cf9f1d9 | 0 | static struct XenDevice *xen_be_del_xendev(int dom, int dev)
{
struct XenDevice *xendev, *xnext;
/*
* This is pretty much like QTAILQ_FOREACH(xendev, &xendevs, next) but
* we save the next pointer in xnext because we might free xendev.
*/
xnext = xendevs.tqh_first;
while (xnext)... | 25,017 |
FFmpeg | c04c52d3a8bb323d71436512495c8ecf58be69ee | 0 | static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, unsigned int max_pos, int depth) {
AVCodecContext *acodec, *vcodec;
ByteIOContext *ioc;
AMFDataType amf_type;
char str_val[256];
double num_val;
num_val = 0;
ioc = s->pb;
am... | 25,018 |
qemu | 4e2e4e6355959a1af011167b0db5ac7ffd3adf94 | 0 | static void kvm_init_irq_routing(KVMState *s)
{
int gsi_count;
gsi_count = kvm_check_extension(s, KVM_CAP_IRQ_ROUTING);
if (gsi_count > 0) {
unsigned int gsi_bits, i;
/* Round up so we can search ints using ffs */
gsi_bits = ALIGN(gsi_count, 32);
s->used_gsi_bitma... | 25,019 |
qemu | af52fe862fba686713044efdf9158195f84535ab | 0 | static void uart_read_rx_fifo(UartState *s, uint32_t *c)
{
if ((s->r[R_CR] & UART_CR_RX_DIS) || !(s->r[R_CR] & UART_CR_RX_EN)) {
return;
}
if (s->rx_count) {
uint32_t rx_rpos =
(RX_FIFO_SIZE + s->rx_wpos - s->rx_count) % RX_FIFO_SIZE;
*c = s->rx_fifo[rx_rpos... | 25,020 |
qemu | 41ecc72ba5932381208e151bf2d2149a0342beff | 0 | static void setup_frame(int sig, struct target_sigaction *ka,
target_sigset_t *set, CPUAlphaState *env)
{
abi_ulong frame_addr, r26;
struct target_sigframe *frame;
int err = 0;
frame_addr = get_sigframe(ka, env, sizeof(*frame));
if (!lock_user_struct(VERIFY_WRITE, fr... | 25,021 |
qemu | 6d18a7a1ff9665ad48a68a692fdf0a61edefcae8 | 0 | static void spin_kick(void *data)
{
SpinKick *kick = data;
CPUState *cpu = CPU(kick->cpu);
CPUPPCState *env = &kick->cpu->env;
SpinInfo *curspin = kick->spin;
hwaddr map_size = 64 * 1024 * 1024;
hwaddr map_start;
cpu_synchronize_state(cpu);
stl_p(&curspin->pir, env->spr[SPR_PI... | 25,022 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | static void sd_blk_write(SDState *sd, uint64_t addr, uint32_t len)
{
uint64_t end = addr + len;
if ((addr & 511) || len < 512)
if (!sd->bdrv || bdrv_read(sd->bdrv, addr >> 9, sd->buf, 1) < 0) {
fprintf(stderr, "sd_blk_write: read error on host side\n");
return;
}... | 25,023 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static struct omap_uwire_s *omap_uwire_init(MemoryRegion *system_memory,
target_phys_addr_t base,
qemu_irq txirq, qemu_irq rxirq,
qemu_irq dma,
... | 25,025 |
qemu | 0c33682d5f29b0a4ae53bdec4c8e52e4fae37b34 | 0 | static void exception_action(CPUState *cpu)
{
#if defined(TARGET_I386)
X86CPU *x86_cpu = X86_CPU(cpu);
CPUX86State *env1 = &x86_cpu->env;
raise_exception_err(env1, cpu->exception_index, env1->error_code);
#else
cpu_loop_exit(cpu);
#endif
}
| 25,026 |
qemu | 7e2515e87c41e2e658aaed466e11cbdf1ea8bcb1 | 0 | void term_printf(const char *fmt, ...)
{
char buf[4096];
va_list ap;
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
qemu_chr_write(monitor_hd, buf, strlen(buf));
va_end(ap);
}
| 25,027 |
qemu | 28b70c9dbdce0d517ade9c04c7d7ae05c8b76d2f | 0 | static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
{
switch (buf[0] >> 5) {
case 0:
cmd->xfer = buf[4];
cmd->len = 6;
break;
case 1:
case 2:
cmd->xfer = lduw_be_p(&buf[7]);
cmd->len = 10;
break;
case 4:
cmd... | 25,028 |
FFmpeg | 8aeb33225aed5a0da03f9145a09ca1bbd6ac6532 | 0 | static void draw_slice(AVFilterLink *link, int y, int h)
{
ScaleContext *scale = link->dst->priv;
int out_h;
AVFilterPicRef *cur_pic = link->cur_pic;
uint8_t *data[4];
if (!scale->slice_dir) {
if (y != 0 && y + h != link->h) {
av_log(scale, AV_LOG_ERROR, "Slices start i... | 25,029 |
qemu | cca7fad5765251fece44cd230156a101867522dd | 0 | static void spapr_phb_finish_realize(sPAPRPHBState *sphb, Error **errp)
{
sphb->dma_window_start = 0;
sphb->dma_window_size = 0x40000000;
sphb->tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn,
sphb->dma_window_size);
if (!sphb->tcet) {
error_s... | 25,030 |
qemu | 973945804d95878375b487c0c5c9b2556c5e4543 | 0 | static void tcx_rblit_writel(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
TCXState *s = opaque;
uint32_t adsr, len;
int i;
if (!(addr & 4)) {
s->tmpblit = val;
} else {
addr = (addr >> 3) & 0xfffff;
adsr = val & 0xffffff;
... | 25,031 |
qemu | 130257dc443574a9da91dc293665be2cfc40245a | 0 | static CharDriverState *qemu_chr_open_mux(const char *id,
ChardevBackend *backend,
ChardevReturn *ret, Error **errp)
{
ChardevMux *mux = backend->mux;
CharDriverState *chr, *drv;
MuxDriver *d;
drv = qemu_chr_fin... | 25,032 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | static void pmac_ide_transfer(DBDMA_io *io)
{
MACIOIDEState *m = io->opaque;
IDEState *s = idebus_active_if(&m->bus);
MACIO_DPRINTF("\n");
s->io_buffer_size = 0;
if (s->drive_kind == IDE_CD) {
/* Handle non-block ATAPI DMA transfers */
if (s->lba == -1) {
s... | 25,033 |
qemu | cc0c4185e54867ef93c4b4dc0a8f3ecbc20ece42 | 0 | static void do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
int index = qdict_get_int(qdict, "index");
if (mon_set_cpu(index) < 0)
qemu_error_new(QERR_INVALID_CPU_INDEX);
}
| 25,034 |
qemu | 88e8add8b6656c349a96b447b074688d02dc5415 | 0 | static int get_phys_addr_lpae(CPUARMState *env, target_ulong address,
int access_type, ARMMMUIdx mmu_idx,
hwaddr *phys_ptr, MemTxAttrs *txattrs, int *prot,
target_ulong *page_size_ptr)
{
CPUState *cs = CPU(arm_env_get_cpu... | 25,035 |
qemu | 8b714d3747e6870db85dd9382adb8ee371633092 | 1 | static void qmp_input_start_struct(Visitor *v, void **obj, const char *kind,
const char *name, size_t size, Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
const QObject *qobj = qmp_input_get_object(qiv, name);
if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
... | 25,036 |
FFmpeg | fd2784c3b5e5ea13dd308b1eeeef0dd3c22a3d4a | 1 | static int join_request_frame(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
JoinContext *s = ctx->priv;
AVFilterBufferRef *buf;
JoinBufferPriv *priv;
int linesize = INT_MAX;
int perms = ~0;
int nb_samples;
int i, j, ret;
/* get a frame on each... | 25,037 |
FFmpeg | 8b2fce0d3f5a56c40c28899c9237210ca8f9cf75 | 1 | static inline void yuv2yuvXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int chrDstW)
{
//FIXME Optimize (just quickly wr... | 25,038 |
qemu | 9a94ee5bb15793ef69692998ef57794a33074134 | 1 | static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
target_ulong id, start, r3;
PowerPCCPU *cpu;
if (nargs != 3 ... | 25,039 |
FFmpeg | b69b43e2c471c4febbffaf313875396256b6a51e | 1 | static void check_decode_result(int *got_output, int ret)
{
if (*got_output || ret<0)
decode_error_stat[ret<0] ++;
if (ret < 0 && exit_on_error)
exit_program(1);
}
| 25,040 |
qemu | 128e4e108949b35dbe351fe122a3e34b834e185a | 1 | int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
const VMStateDescription *vmsd,
void *opaque, int alias_id,
int required_for_version,
Error **errp)
{
... | 25,041 |
qemu | d6f723b513a0c3c4e58343b7c52a2f9850861fa0 | 1 | static void test_qemu_strtoll_max(void)
{
const char *str = g_strdup_printf("%lld", LLONG_MAX);
char f = 'X';
const char *endptr = &f;
int64_t res = 999;
int err;
err = qemu_strtoll(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, LLONG_MAX);
... | 25,042 |
FFmpeg | 2e59ffbb7964214e192a9f77c4445ff29c6510d7 | 1 | static int mace_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AVFrame *frame = data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int16_t **samples;
MACEContext *ctx = avctx->priv_data;
int i, j, k, l, ret... | 25,043 |
FFmpeg | be524ffc16bf14cab0ad112b0dcb48d09a2a40ff | 1 | static av_cold int rv30_decode_init(AVCodecContext *avctx)
{
RV34DecContext *r = avctx->priv_data;
int ret;
r->rv30 = 1;
if ((ret = ff_rv34_decode_init(avctx)) < 0)
return ret;
if(avctx->extradata_size < 2){
av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
... | 25,044 |
qemu | 04c5b17a74c9d6c309181079f8949665b43b0164 | 1 | static int cpu_x86_find_by_name(x86_def_t *x86_cpu_def, const char *cpu_model)
{
unsigned int i;
x86_def_t *def;
char *s = g_strdup(cpu_model);
char *featurestr, *name = strtok(s, ",");
/* Features to be added*/
uint32_t plus_features = 0, plus_ext_features = 0;
uint32_t plus_ext2_... | 25,045 |
qemu | 6b860806c0dd881373ead661c0f3499eca2c3995 | 1 | static int virtio_gpu_ui_info(void *opaque, uint32_t idx, QemuUIInfo *info)
{
VirtIOGPU *g = opaque;
if (idx > g->conf.max_outputs) {
return -1;
}
g->req_state[idx].x = info->xoff;
g->req_state[idx].y = info->yoff;
g->req_state[idx].width = info->width;
g->req_state[idx]... | 25,046 |
qemu | 44d691f7d9b6ebab102a31aa87fe59da8f7feff9 | 1 | void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev,
Error **errp)
{
sPAPRCPUCore *core = SPAPR_CPU_CORE(OBJECT(dev));
PowerPCCPU *cpu = POWERPC_CPU(core->threads);
int id = ppc_get_vcpu_dt_id(cpu);
sPAPRDRConnector *drc =
spapr_dr_connector_by_id(S... | 25,047 |
qemu | a9fc37f6bc3f2ab90585cb16493da9f6dcfbfbcf | 1 | static void qobject_input_check_struct(Visitor *v, Error **errp)
{
QObjectInputVisitor *qiv = to_qiv(v);
StackObject *tos = QSLIST_FIRST(&qiv->stack);
assert(tos && !tos->entry);
if (qiv->strict) {
GHashTable *const top_ht = tos->h;
if (top_ht) {
GHashTableIter iter... | 25,048 |
FFmpeg | dcc39ee10e82833ce24aa57926c00ffeb1948198 | 0 | static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
const uint8_t **buf, int buf_size)
{
AVCodecContext *avctx = s->avctx;
const int field_pic = s->picture_structure != PICT_FRAME;
int ret;
s->resync_mb_x =
s->resync_mb_y = -1;
assert(mb_y < s->mb... | 25,050 |
qemu | 40a0d7c395f4d18a8061ba075d8f9aab2fa0ec2a | 1 | create_iovec(QEMUIOVector *qiov, char **argv, int nr_iov, int pattern)
{
size_t *sizes = calloc(nr_iov, sizeof(size_t));
size_t count = 0;
void *buf, *p;
int i;
for (i = 0; i < nr_iov; i++) {
char *arg = argv[i];
long long len;
len = cvtnum(arg);
if (len < 0) {
printf("non-numeric length ... | 25,052 |
FFmpeg | f66f3819b96847cd28589b718dbcd03b782e7a5c | 1 | static int vid_probe(AVProbeData *p)
{
// little-endian VID tag, file starts with "VID\0"
if (AV_RL32(p->buf) != MKTAG('V', 'I', 'D', 0))
return 0;
return AVPROBE_SCORE_MAX;
} | 25,053 |
qemu | 068abdc8a57023eeafe1025b964a50f8a39929b4 | 1 | void ppc_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
{
int i;
for (i = 0; ; i++) {
(*cpu_fprintf)(f, "PowerPC %-16s PVR %08x\n",
ppc_defs[i].name, ppc_defs[i].pvr);
if (strcmp(ppc_defs[i].name, "default") == 0)
break;
}
... | 25,054 |
qemu | fde9bf4470d4a3b6ee1da0dee2370ab028b6314a | 1 | void object_delete(Object *obj)
{
object_unparent(obj);
g_assert(obj->ref == 1);
object_unref(obj);
g_free(obj);
}
| 25,055 |
FFmpeg | bb463d81020a2f3c5cf3403e18f980171773f48a | 0 | static int mpeg_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
Mpeg1Context *s = avctx->priv_data;
uint8_t *buf_end, *buf_ptr;
int ret, start_code, input_size;
AVFrame *picture = data;
M... | 25,056 |
qemu | f2917853f715b0ef55df29eb2ffea29dc69ce814 | 1 | static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun,
int evpd, int pc)
{
int full_size;
struct scsi_task *task = NULL;
task = iscsi_inquiry_sync(iscsi, lun, evpd, pc, 64);
if (task == NULL || task->status != SCSI_STATUS_GOOD) {
... | 25,057 |
qemu | ad0ebb91cd8b5fdc4a583b03645677771f420a46 | 1 | static target_ulong h_add_logical_lan_buffer(CPUPPCState *env,
sPAPREnvironment *spapr,
target_ulong opcode,
target_ulong *args)
{
target_ulong reg = args[0];
target_ulong... | 25,059 |
qemu | b14ef7c9ab41ea824c3ccadb070ad95567cca84e | 1 | static uint32_t unassigned_mem_readw(void *opaque, target_phys_addr_t addr)
{
#ifdef DEBUG_UNASSIGNED
printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
#endif
#if defined(TARGET_ALPHA) || defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
do_unassigned_access(addr, 0, 0, 0, 2);
#endif
retur... | 25,060 |
FFmpeg | bcaf64b605442e1622d16da89d4ec0e7730b8a8c | 0 | static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr)
{
int n, c, sample_size, v, ret;
const short *samples;
unsigned char *dst;
const uint8_t *samples_uint8_t;
const int16_t *samples_int16_t;
const int3... | 25,061 |
FFmpeg | 80ee9fc0e305b815b4b67bbf8fa9ceccdc1d369e | 0 | static int RENAME(epzs_motion_search)(MpegEncContext * s,
int *mx_ptr, int *my_ptr,
int P[10][2], int pred_x, int pred_y, uint8_t *src_data[3],
uint8_t *ref_data[3], int stride, int uvstride, int16_t (*last_mv)[2],
... | 25,062 |
qemu | 6df5718bd3ec56225c44cf96440c723c1b611b87 | 1 | static void megasas_complete_frame(MegasasState *s, uint64_t context)
{
PCIDevice *pci_dev = PCI_DEVICE(s);
int tail, queue_offset;
/* Decrement busy count */
s->busy--;
if (s->reply_queue_pa) {
/*
* Put command on the reply queue.
* Context is opaque, but emul... | 25,063 |
FFmpeg | 6138ed777db101c26d19b96e6a27b8499ab9f4e7 | 1 | static int decode_residual_block(AVSContext *h, GetBitContext *gb,
const dec_2dvlc_t *r, int esc_golomb_order,
int qp, uint8_t *dst, int stride) {
int i, level_code, esc_code, level, run, mask;
DCTELEM level_buf[64];
uint8_t run_buf[64];... | 25,064 |
FFmpeg | 1269cd5b6f540bef5913bf134d2f461aac50d70b | 1 | int ff_thread_decode_frame(AVCodecContext *avctx,
AVFrame *picture, int *got_picture_ptr,
AVPacket *avpkt)
{
FrameThreadContext *fctx = avctx->internal->thread_ctx;
int finished = fctx->next_finished;
PerThreadContext *p;
int err;
/* re... | 25,065 |
qemu | 9b2fadda3e0196ffd485adde4fe9cdd6fae35300 | 1 | static void gen_tlbld_6xx(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_6xx_tlbd(cpu_env, cpu_gpr[rB(ctx->opcode)]);
#endif... | 25,067 |
qemu | aa0568ff2559d7717f4684af6a83d0bd1a125f56 | 1 | static int ehci_process_itd(EHCIState *ehci,
EHCIitd *itd)
{
USBDevice *dev;
USBEndpoint *ep;
int ret;
uint32_t i, len, pid, dir, devaddr, endp;
uint32_t pg, off, ptr1, ptr2, max, mult;
dir =(itd->bufptr[1] & ITD_BUFPTR_DIRECTION);
devaddr = get_field(i... | 25,068 |
FFmpeg | 87e8788680e16c51f6048af26f3f7830c35207a5 | 0 | static int swf_probe(AVProbeData *p)
{
/* check file header */
if (p->buf_size <= 16)
return 0;
if ((p->buf[0] == 'F' || p->buf[0] == 'C') && p->buf[1] == 'W' &&
p->buf[2] == 'S')
return AVPROBE_SCORE_MAX;
else
return 0;
}
| 25,069 |
FFmpeg | 4240e6a92117811509be3e5f360a44dde8618040 | 0 | static int16_t *precalc_coefs(double dist25, int depth)
{
int i;
double gamma, simil, C;
int16_t *ct = av_malloc((512<<LUT_BITS)*sizeof(int16_t));
if (!ct)
return NULL;
gamma = log(0.25) / log(1.0 - FFMIN(dist25,252.0)/255.0 - 0.00001);
for (i = -255<<LUT_BITS; i <= 255<<LUT_... | 25,070 |
FFmpeg | bcd7bf7eeb09a395cc01698842d1b8be9af483fc | 0 | static void avc_biwgt_4x2_msa(uint8_t *src,
int32_t src_stride,
uint8_t *dst,
int32_t dst_stride,
int32_t log2_denom,
int32_t src_weight,
... | 25,072 |
FFmpeg | fdbc544d29176ba69d67dd879df4696f0a19052e | 1 | static int asf_read_value(AVFormatContext *s, uint8_t *name, uint16_t name_len,
uint16_t val_len, int type, AVDictionary **met)
{
int ret;
uint8_t *value;
uint16_t buflen = 2 * val_len + 1;
AVIOContext *pb = s->pb;
value = av_malloc(buflen);
if (!value)
... | 25,073 |
qemu | 5839e53bbc0fec56021d758aab7610df421ed8c8 | 1 | static int vdi_check(BlockDriverState *bs, BdrvCheckResult *res,
BdrvCheckMode fix)
{
/* TODO: additional checks possible. */
BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
uint32_t blocks_allocated = 0;
uint32_t block;
uint32_t *bmap;
logout("\n");
if (fix) {
... | 25,074 |
qemu | 6ab3fc32ea640026726bc5f9f4db622d0954fb8a | 1 | static void uart_write(void *opaque, hwaddr addr,
uint64_t value, unsigned size)
{
LM32UartState *s = opaque;
unsigned char ch = value;
trace_lm32_uart_memory_write(addr, value);
addr >>= 2;
switch (addr) {
case R_RXTX:
if (s->chr) {
qem... | 25,076 |
qemu | 75cdcd1553e74b5edc58aed23e3b2da8dabb1876 | 1 | static void test_opts_parse_size(void)
{
Error *err = NULL;
QemuOpts *opts;
/* Lower limit zero */
opts = qemu_opts_parse(&opts_list_02, "size1=0", false, &error_abort);
g_assert_cmpuint(opts_count(opts), ==, 1);
g_assert_cmpuint(qemu_opt_get_size(opts, "size1", 1), ==, 0);
/* No... | 25,078 |
qemu | 3713e1485e6eace7d48b9c790602cfd92c616e5f | 1 | static int usbredir_post_load(void *priv, int version_id)
{
USBRedirDevice *dev = priv;
switch (dev->device_info.speed) {
case usb_redir_speed_low:
dev->dev.speed = USB_SPEED_LOW;
break;
case usb_redir_speed_full:
dev->dev.speed = USB_SPEED_FULL;
break;
case usb_redir... | 25,079 |
FFmpeg | 1007a805a486a1348a0543ac2dd99d823148d25c | 1 | static void smc_decode_stream(SmcContext *s)
{
int width = s->avctx->width;
int height = s->avctx->height;
int stride = s->frame.linesize[0];
int i;
int stream_ptr = 0;
int chunk_size;
unsigned char opcode;
int n_blocks;
unsigned int color_flags;
unsigned int color_fla... | 25,080 |
qemu | e3c9d76acc984218264bbc6435b0c09f959ed9b8 | 1 | static void vhost_scsi_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
dc->exit = vhost_scsi_exit;
dc->props = vhost_scsi_properties;
set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
vdc->init = vhos... | 25,082 |
qemu | 45b00c44ceffeac8143fb8857a12677234114f2b | 1 | ivshmem_client_parse_args(IvshmemClientArgs *args, int argc, char *argv[])
{
int c;
while ((c = getopt(argc, argv,
"h" /* help */
"v" /* verbose */
"S:" /* unix_sock_path */
)) != -1) {
switch (c) {
... | 25,083 |
FFmpeg | c4c0245686bc2fcc545644101c7b328fed71f268 | 1 | static int estimate_sid_gain(G723_1_Context *p)
{
int i, shift, seg, seg2, t, val, val_add, x, y;
shift = 16 - p->cur_gain * 2;
if (shift > 0)
t = p->sid_gain << shift;
else
t = p->sid_gain >> -shift;
x = av_clipl_int32(t * (int64_t)cng_filt[0] >> 16);
if (x >= cng_b... | 25,084 |
FFmpeg | b4bccf3e4e58f6fe58043791ca09db01a4343fac | 1 | static int decode_exp_vlc(WMACodecContext *s, int ch)
{
int last_exp, n, code;
const uint16_t *ptr;
float v, max_scale;
uint32_t *q, *q_end, iv;
const float *ptab = pow_tab + 60;
const uint32_t *iptab = (const uint32_t*)ptab;
ptr = s->exponent_bands[s->frame_len_bits - s->block_len... | 25,085 |
FFmpeg | ae7a4a1594e3624f7c844dec44266d2dc74a6be2 | 1 | static int decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
{
BC_STATUS ret;
BC_DTS_STATUS decoder_status;
CopyRet rec_ret;
CHDContext *priv = avctx->priv_data;
HANDLE dev = priv->dev;
int len = avpkt->size;
uint8_t pic_type = 0;
... | 25,086 |
FFmpeg | 7effbee66cf457c62f795d9b9ed3a1110b364b89 | 1 | static int au_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
int ret;
ret= av_get_packet(s->pb, pkt, BLOCK_SIZE *
s->streams[0]->codec->channels *
av_get_bits_per_sample(s->streams[0]->codec->codec_id) >> 3);
if (ret < 0)
... | 25,087 |
FFmpeg | 50d2d05d3436922e89fcdfdd87411669eab61c02 | 0 | static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
{
int tag = track->enc->codec_tag;
if (track->mode == MODE_MP4 || track->mode == MODE_PSP) {
if (!codec_get_tag(ff_mp4_obj_type, track->enc->codec_id))
return 0;
if (track->enc->codec_id == CODEC_ID_H264) ... | 25,088 |
FFmpeg | 67db4ff3b66e96a20ddf1c264d07e146334ae88e | 0 | static av_cold void nvenc_setup_rate_control(AVCodecContext *avctx)
{
NvencContext *ctx = avctx->priv_data;
if (avctx->bit_rate > 0) {
ctx->encode_config.rcParams.averageBitRate = avctx->bit_rate;
} else if (ctx->encode_config.rcParams.averageBitRate > 0) {
ctx->encode_config.rcParam... | 25,092 |
FFmpeg | de8cac167d52557aa0aced5c013c98f44ade98cf | 0 | int ff_rv34_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
RV34DecContext *r = avctx->priv_data;
MpegEncContext *s = &r->s;
AVFrame *pict = data;
SliceInfo si;
int i;
int slice_count;
... | 25,093 |
FFmpeg | 03037a4aad8b92c00ef2f115605ad20fc4410fe5 | 0 | static void blend_subrect(AVPicture *dst, const AVSubtitleRect *rect, int imgw, int imgh)
{
int x, y, Y, U, V, A;
uint8_t *lum, *cb, *cr;
int dstx, dsty, dstw, dsth;
const AVPicture *src = &rect->pict;
dstw = av_clip(rect->w, 0, imgw);
dsth = av_clip(rect->h, 0, imgh);
dstx = av_cl... | 25,094 |
FFmpeg | a606f27f4c610708fa96e35eed7b7537d3d8f712 | 0 | int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
{
int len;
if (size < 0)
return -1;
if (s->read_packet && s->write_flag) {
len = s->read_packet(s->opaque, buf, size);
if (len > 0)
s->pos += len;
return len;
}
len = s->b... | 25,096 |
FFmpeg | 934982c4ace1a3d5d627b518782ed092a456c49e | 0 | static int sp5x_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
#if 0
MJpegDecodeContext *s = avctx->priv_data;
#endif
const int qscale = 5;
uint8_t *buf_ptr, *buf_end, *recoded;
int i = 0... | 25,097 |
qemu | 7385aed20db5d83979f683b9d0048674411e963c | 0 | float32 helper_fdtos(CPUSPARCState *env, float64 src)
{
float32 ret;
clear_float_exceptions(env);
ret = float64_to_float32(src, &env->fp_status);
check_ieee_exceptions(env);
return ret;
}
| 25,099 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void icp_control_init(target_phys_addr_t base)
{
MemoryRegion *io;
io = (MemoryRegion *)g_malloc0(sizeof(MemoryRegion));
memory_region_init_io(io, &icp_control_ops, NULL,
"control", 0x00800000);
memory_region_add_subregion(get_system_memory(), base, io);
/* ... | 25,100 |
qemu | cd42d5b23691ad73edfd6dbcfc935a960a9c5a65 | 0 | gen_intermediate_code_internal(MoxieCPU *cpu, TranslationBlock *tb,
bool search_pc)
{
CPUState *cs = CPU(cpu);
DisasContext ctx;
target_ulong pc_start;
uint16_t *gen_opc_end;
CPUBreakpoint *bp;
int j, lj = -1;
CPUMoxieState *env = &cpu->env;
int n... | 25,101 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 0 | USBBus *usb_bus_find(int busnr)
{
USBBus *bus;
if (-1 == busnr)
return TAILQ_FIRST(&busses);
TAILQ_FOREACH(bus, &busses, next) {
if (bus->busnr == busnr)
return bus;
}
return NULL;
}
| 25,102 |
qemu | 1687a089f103f9b7a1b4a1555068054cb46ee9e9 | 0 | vreader_copy_list(VReaderList *list)
{
VReaderList *new_list = NULL;
VReaderListEntry *current_entry = NULL;
new_list = vreader_list_new();
if (new_list == NULL) {
return NULL;
}
for (current_entry = vreader_list_get_first(list); current_entry;
current_entry = vreader... | 25,104 |
qemu | 550830f9351291c585c963204ad9127998b1c1ce | 0 | static int cow_find_streak(const uint8_t *bitmap, int value, int start, int nb_sectors)
{
int streak_value = value ? 0xFF : 0;
int last = MIN(start + nb_sectors, BITS_PER_BITMAP_SECTOR);
int bitnum = start;
while (bitnum < last) {
if ((bitnum & 7) == 0 && bitmap[bitnum / 8] == streak_value... | 25,105 |
qemu | 2e6fc7eb1a4af1b127df5f07b8bb28af891946fa | 0 | static int raw_read_options(QDict *options, BlockDriverState *bs,
BDRVRawState *s, Error **errp)
{
Error *local_err = NULL;
QemuOpts *opts = NULL;
int64_t real_size = 0;
int ret;
real_size = bdrv_getlength(bs->file->bs);
if (real_size < 0) {
error_setg_errno(errp, -real_si... | 25,106 |
FFmpeg | d1adad3cca407f493c3637e20ecd4f7124e69212 | 0 | static inline void RENAME(hyscale_fast)(SwsContext *c, int16_t *dst,
long dstWidth, const uint8_t *src, int srcW,
int xInc)
{
#if ARCH_X86
#if COMPILE_TEMPLATE_MMX2
int32_t *filterPos = c->hLumFilterPos;
int16_t *filter = ... | 25,107 |
qemu | 21e00fa55f3fdfcbb20da7c6876c91ef3609b387 | 0 | bool memory_region_is_skip_dump(MemoryRegion *mr)
{
return mr->skip_dump;
}
| 25,108 |
qemu | 185b43386ad999c80bdc58e41b87f05e5b3e8463 | 0 | static ssize_t nbd_send_reply(int csock, struct nbd_reply *reply)
{
uint8_t buf[4 + 4 + 8];
/* Reply
[ 0 .. 3] magic (NBD_REPLY_MAGIC)
[ 4 .. 7] error (0 == no error)
[ 7 .. 15] handle
*/
cpu_to_be32w((uint32_t*)buf, NBD_REPLY_MAGIC);
cpu_to_be32w((uin... | 25,109 |
qemu | 7848c8d19f8556666df25044bbd5d8b29439c368 | 0 | static void switch_tss(CPUX86State *env, int tss_selector,
uint32_t e1, uint32_t e2, int source,
uint32_t next_eip)
{
int tss_limit, tss_limit_max, type, old_tss_limit_max, old_type, v1, v2, i;
target_ulong tss_base;
uint32_t new_regs[8], new_segs[6];
... | 25,110 |
qemu | a36593e16757e524c1596d93914155bd8acbb90a | 0 | void kvmppc_read_hptes(ppc_hash_pte64_t *hptes, hwaddr ptex, int n)
{
int fd, rc;
int i;
fd = kvmppc_get_htab_fd(false, ptex, &error_abort);
i = 0;
while (i < n) {
struct kvm_get_htab_header *hdr;
int m = n < HPTES_PER_GROUP ? n : HPTES_PER_GROUP;
char buf[sizeof... | 25,111 |
qemu | 1830f22a6777cedaccd67a08f675d30f7a85ebfd | 0 | void qmp_output_visitor_cleanup(QmpOutputVisitor *v)
{
QStackEntry *e, *tmp;
QTAILQ_FOREACH_SAFE(e, &v->stack, node, tmp) {
QTAILQ_REMOVE(&v->stack, e, node);
g_free(e);
}
qobject_decref(v->root);
g_free(v);
}
| 25,112 |
qemu | 01c2b265fce921d6460e06f5af4dfb405119cbab | 0 | static int check_host_key(BDRVSSHState *s, const char *host, int port,
const char *host_key_check)
{
/* host_key_check=no */
if (strcmp(host_key_check, "no") == 0) {
return 0;
}
/* host_key_check=md5:xx:yy:zz:... */
if (strncmp(host_key_check, "md5:", 4) =... | 25,114 |
qemu | bd2bfa4c52e5f4dc6dbaa5be0521aedc31cb53d9 | 0 | void memory_region_notify_iommu(MemoryRegion *mr,
IOMMUTLBEntry entry)
{
IOMMUNotifier *iommu_notifier;
IOMMUNotifierFlag request_flags;
assert(memory_region_is_iommu(mr));
if (entry.perm & IOMMU_RW) {
request_flags = IOMMU_NOTIFIER_MAP;
} else {
... | 25,115 |
qemu | d185c094b404b4ff392b77d1244c0233da7d53bd | 0 | static IOWatchPoll *io_watch_poll_from_source(GSource *source)
{
IOWatchPoll *i;
QTAILQ_FOREACH(i, &io_watch_poll_list, node) {
if (i->src == source) {
return i;
}
}
return NULL;
}
| 25,116 |
qemu | ec05ec26f940564b1e07bf88857035ec27e21dd8 | 0 | void memory_region_init_io(MemoryRegion *mr,
Object *owner,
const MemoryRegionOps *ops,
void *opaque,
const char *name,
uint64_t size)
{
memory_region_init(mr, owner, name, s... | 25,117 |
FFmpeg | 53c05b1eacd5f7dbfa3651b45e797adaea0a5ff8 | 0 | static void filter_mb( H264Context *h, int mb_x, int mb_y ) {
MpegEncContext * const s = &h->s;
const int mb_xy= mb_x + mb_y*s->mb_stride;
uint8_t *img_y = s->current_picture.data[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
uint8_t *img_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) ... | 25,118 |
FFmpeg | f6774f905fb3cfdc319523ac640be30b14c1bc55 | 1 | void mpeg_motion_internal(MpegEncContext *s,
uint8_t *dest_y,
uint8_t *dest_cb,
uint8_t *dest_cr,
int field_based,
int bottom_field,
int field_select,
... | 25,120 |
qemu | eb7a20a3616085d46aa6b4b4224e15587ec67e6e | 1 | static void i6300esb_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->config_read = i6300esb_config_read;
k->config_write = i6300esb_config_write;
k->realize = i6300esb_realize;
k->vendor_id = PCI_VENDOR... | 25,121 |
qemu | 4b6af3d58a73193017926dd59de3b3e7b4890323 | 1 | BlockDriverAIOCB *win32_aio_submit(BlockDriverState *bs,
QEMUWin32AIOState *aio, HANDLE hfile,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type)
{
struct QEMUWin32AIOCB *waiocb;
uint64_t offset = sector_num * 512;
DW... | 25,122 |
FFmpeg | 5b0fc078191138795e817244555741356f9d12e9 | 1 | static av_cold int vp9_decode_free(AVCodecContext *ctx)
{
VP9Context *s = ctx->priv_data;
int i;
for (i = 0; i < 2; i++) {
if (s->frames[i].tf.f->data[0])
vp9_unref_frame(ctx, &s->frames[i]);
av_frame_free(&s->frames[i].tf.f);
}
for (i = 0; i < 8; i++) {
... | 25,124 |
qemu | 5839e53bbc0fec56021d758aab7610df421ed8c8 | 1 | static int sd_create(const char *filename, QemuOpts *opts,
Error **errp)
{
int ret = 0;
uint32_t vid = 0;
char *backing_file = NULL;
char *buf = NULL;
BDRVSheepdogState *s;
char tag[SD_MAX_VDI_TAG_LEN];
uint32_t snapid;
bool prealloc = false;
s = g_m... | 25,125 |
qemu | a1a6bbde4f6a29368f8f605cea2e73630ec1bc7c | 1 | static void ics_base_realize(DeviceState *dev, Error **errp)
{
ICSStateClass *icsc = ICS_BASE_GET_CLASS(dev);
ICSState *ics = ICS_BASE(dev);
Object *obj;
Error *err = NULL;
obj = object_property_get_link(OBJECT(dev), ICS_PROP_XICS, &err);
if (!obj) {
error_setg(errp, "%s: requi... | 25,126 |
FFmpeg | 78baa450d9939957f52d5187beb95d763d2f1f18 | 1 | static int ffm_read_header(AVFormatContext *s)
{
FFMContext *ffm = s->priv_data;
AVStream *st;
AVIOContext *pb = s->pb;
AVCodecContext *codec;
const AVCodecDescriptor *codec_desc;
int i, nb_streams;
uint32_t tag;
/* header */
tag = avio_rl32(pb);
if (tag == MKTAG('F'... | 25,127 |
qemu | 5820945946b1e221905aa898f2cd97ed825acd47 | 1 | static void shpc_interrupt_update(PCIDevice *d)
{
SHPCDevice *shpc = d->shpc;
int slot;
int level = 0;
uint32_t serr_int;
uint32_t int_locator = 0;
/* Update interrupt locator register */
for (slot = 0; slot < shpc->nslots; ++slot) {
uint8_t event = shpc->config[SHPC_SLOT_... | 25,128 |
qemu | 983bff3530782d51c46c8d7c0e17e2a9dfe5fb77 | 1 | static void usb_mtp_command(MTPState *s, MTPControl *c)
{
MTPData *data_in = NULL;
MTPObject *o;
uint32_t nres = 0, res0 = 0;
/* sanity checks */
if (c->code >= CMD_CLOSE_SESSION && s->session == 0) {
usb_mtp_queue_result(s, RES_SESSION_NOT_OPEN,
c->tra... | 25,129 |
FFmpeg | 4b030025278ac4adc3616510f36de4c7a113c5fb | 1 | static int sdp_read_header(AVFormatContext *s)
{
RTSPState *rt = s->priv_data;
RTSPStream *rtsp_st;
int size, i, err;
char *content;
char url[1024];
if (!ff_network_init())
return AVERROR(EIO);
if (s->max_delay < 0) /* Not set by the caller */
s->max_delay = DEF... | 25,131 |
qemu | c05541ee191107eb35093fb693e4ec038e60d2c0 | 1 | static inline void gen_op_mfspr(DisasContext *ctx)
{
void (*read_cb)(void *opaque, int gprn, int sprn);
uint32_t sprn = SPR(ctx->opcode);
#if !defined(CONFIG_USER_ONLY)
if (ctx->mem_idx == 2)
read_cb = ctx->spr_cb[sprn].hea_read;
else if (ctx->mem_idx)
read_cb = ctx->spr_cb[spr... | 25,132 |
FFmpeg | 4d122b01e4ce539269ee2df193b061772c7374f6 | 1 | static int mov_create_chapter_track(AVFormatContext *s, int tracknum)
{
MOVMuxContext *mov = s->priv_data;
MOVTrack *track = &mov->tracks[tracknum];
AVPacket pkt = { .stream_index = tracknum, .flags = AV_PKT_FLAG_KEY };
int i, len;
// These properties are required to make QT recognize the chap... | 25,133 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.