id int32 0 27.3k | func stringlengths 26 142k | target bool 2
classes | project stringclasses 2
values | commit_id stringlengths 40 40 |
|---|---|---|---|---|
3,797 | AioContext *bdrv_get_aio_context(BlockDriverState *bs)
{
/* Currently BlockDriverState always uses the main loop AioContext */
return qemu_get_aio_context();
}
| false | qemu | dcd042282d855edf70df90b7d61d33b515320b7a |
3,798 | static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
{
FramePool *pool = s->internal->pool;
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pic->format);
int i;
if (pic->data[0]) {
av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
return... | false | FFmpeg | bdf7093bd0cb78d39df8a32cfdc9188d7a960278 |
3,801 | static int qio_dns_resolver_lookup_sync_nop(QIODNSResolver *resolver,
SocketAddress *addr,
size_t *naddrs,
SocketAddress ***addrs,
Error **e... | false | qemu | dfd100f242370886bb6732f70f1f7cbd8eb9fedc |
3,802 | static int nvdimm_plugged_device_list(Object *obj, void *opaque)
{
GSList **list = opaque;
if (object_dynamic_cast(obj, TYPE_NVDIMM)) {
*list = g_slist_append(*list, DEVICE(obj));
}
object_child_foreach(obj, nvdimm_plugged_device_list, opaque);
return 0;
}
| false | qemu | cf7c0ff521b0710079aa28f21937fb7dbb3f5224 |
3,803 | AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
const char *opaque, Error **errp)
{
int fd;
Monitor *mon = cur_mon;
MonFdset *mon_fdset = NULL;
MonFdsetFd *mon_fdset_fd;
AddfdInfo *fdinfo;
fd = qemu_chr_fe_get_msgfd(mon->chr);
if (... | false | qemu | e446f70d54b4920e8ca5af509271b69eab86e37b |
3,804 | static BlockDriverAIOCB *paio_ioctl(BlockDriverState *bs, int fd,
unsigned long int req, void *buf,
BlockDriverCompletionFunc *cb, void *opaque)
{
RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
acb->bs = bs;
acb->aio_type = QEMU_AIO_IOCTL;
acb->aio_fildes = fd;
acb->a... | false | qemu | c208e8c2d88eea2bbafc2850d8856525637e495d |
3,805 | static int readv_f(BlockBackend *blk, int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, qflag = 0, vflag = 0;
int c, cnt;
char *buf;
int64_t offset;
/* Some compilers get confused and warn if this is not initialized. */
int total = 0;
int nr_iov;
QEMUIOVector ... | false | qemu | b062ad86dcd33ab39be5060b0655d8e13834b167 |
3,806 | static void iter_func(QObject *obj, void *opaque)
{
QInt *qi;
fail_unless(opaque == NULL);
qi = qobject_to_qint(obj);
fail_unless(qi != NULL);
fail_unless((qint_get_int(qi) >= 0) && (qint_get_int(qi) <= iter_max));
iter_called++;
}
| false | qemu | 91479dd0b5bd3b087b92ddd7bc3f2c54982cfe17 |
3,807 | int avfilter_init_str(AVFilterContext *filter, const char *args)
{
return avfilter_init_filter(filter, args, NULL);
}
| false | FFmpeg | 0acf7e268b2f873379cd854b4d5aaba6f9c1f0b5 |
3,808 | SerialState *serial_mm_init(MemoryRegion *address_space,
hwaddr base, int it_shift,
qemu_irq irq, int baudbase,
CharDriverState *chr, enum device_endian end)
{
SerialState *s;
Error *err = NULL;
s = g_malloc0(sizeof... | false | qemu | a30cf8760f4a59797fc060c3c5a13b7749551d0c |
3,809 | static void virtio_net_save_device(VirtIODevice *vdev, QEMUFile *f)
{
VirtIONet *n = VIRTIO_NET(vdev);
int i;
qemu_put_buffer(f, n->mac, ETH_ALEN);
qemu_put_be32(f, n->vqs[0].tx_waiting);
qemu_put_be32(f, n->mergeable_rx_bufs);
qemu_put_be16(f, n->status);
qemu_put_byte(f, n->promi... | false | qemu | 95129d6fc9ead97155627a4ca0cfd37282883658 |
3,810 | udp_listen(port, laddr, lport, flags)
u_int port;
u_int32_t laddr;
u_int lport;
int flags;
{
struct sockaddr_in addr;
struct socket *so;
int addrlen = sizeof(struct sockaddr_in), opt = 1;
if ((so = socreate()) == NULL) {
free(so);
return NULL;
}
so->s = socket(AF_INET,SOCK_DGRAM,0);
so->s... | false | qemu | 242acf3af4605adce933906bdc053b2414181ec7 |
3,812 | void cpu_x86_inject_mce(Monitor *mon, CPUState *cenv, int bank,
uint64_t status, uint64_t mcg_status, uint64_t addr,
uint64_t misc, int flags)
{
unsigned bank_num = cenv->mcg_cap & 0xff;
CPUState *env;
int flag = 0;
if (!cenv->mcg_cap) {
... | false | qemu | d5bfda334adf9af62df5709cdac38f523f815f47 |
3,813 | static void piix3_set_irq(void *opaque, int irq_num, int level)
{
int i, pic_irq, pic_level;
PIIX3State *piix3 = opaque;
/* now we change the pic irq level according to the piix irq mappings */
/* XXX: optimize */
pic_irq = piix3->dev.config[0x60 + irq_num];
if (pic_irq < 16) {
... | false | qemu | ab431c283e7055bcd6fb622f212bb29e84a6a134 |
3,816 | static void mirror_iteration_done(MirrorOp *op, int ret)
{
MirrorBlockJob *s = op->s;
struct iovec *iov;
int64_t chunk_num;
int i, nb_chunks, sectors_per_chunk;
trace_mirror_iteration_done(s, op->sector_num * BDRV_SECTOR_SIZE,
op->nb_sectors * BDRV_SECTOR_SIZ... | false | qemu | b436982f04fb33bb29fcdea190bd1fdc97dc65ef |
3,817 | static ssize_t spapr_vlan_receive(NetClientState *nc, const uint8_t *buf,
size_t size)
{
VIOsPAPRDevice *sdev = DO_UPCAST(NICState, nc, nc)->opaque;
VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
vlan_bd_t rxq_bd = vio_ldq(sdev, dev->buf_list + VLAN_RXQ_BD_OFF);... | false | qemu | a307d59434ba78b97544b42b8cfd24a1b62e39a6 |
3,818 | int av_write_frame(AVFormatContext *s, AVPacket *pkt)
{
int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
return ret;
ret= s->oformat->write_packet(s, pkt);
if(!ret)
ret= url_ferror(s->pb);
return ... | false | FFmpeg | 75b9ed04b977bfd467816f7e60c6511ef89b8a2b |
3,821 | av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)
{
int i, j, n;
if (nbits < 2 || nbits > 16)
goto fail;
s->nbits = nbits;
n = 1 << nbits;
s->revtab = av_malloc(n * sizeof(uint16_t));
if (!s->revtab)
goto fail;
s->tmp_buf = av_malloc(n * sizeof(FFTC... | false | FFmpeg | e6b1ed693ae4098e6b9eabf938fc31ec0b09b120 |
3,822 | DisplaySurface *qemu_create_displaysurface_guestmem(int width, int height,
pixman_format_code_t format,
int linesize, uint64_t addr)
{
DisplaySurface *surface;
hwaddr size;
void *data;
if (li... | true | qemu | f76b84a04b75e98eee56e8dc277564d0fbb99018 |
3,823 | static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
{
AVFilterBufferRef *outpicref = avfilter_ref_buffer(inpicref, ~0);
AVFilterContext *ctx = inlink->dst;
OverlayContext *over = ctx->priv;
av_unused AVFilterLink *outlink = ctx->outputs[0];
inlink->dst->outputs[0]->out... | true | FFmpeg | 06bf6d3bc04979bd39ecdc7311d0daf8aee7e10f |
3,825 | static void monitor_puts(Monitor *mon, const char *str)
{
char c;
for(;;) {
assert(mon->outbuf_index < sizeof(mon->outbuf) - 1);
c = *str++;
if (c == '\0')
break;
if (c == '\n')
mon->outbuf[mon->outbuf_index++] = '\r';
mon->outbuf[mon->... | true | qemu | e1f2641b5926d20f63d36f0de45206be774da8da |
3,826 | void timer_del(QEMUTimer *ts)
{
QEMUTimerList *timer_list = ts->timer_list;
qemu_mutex_lock(&timer_list->active_timers_lock);
timer_del_locked(timer_list, ts);
qemu_mutex_unlock(&timer_list->active_timers_lock);
}
| true | qemu | cd1bd53a669c88f219ca47b538889cd918605fea |
3,827 | static void put_bitmap(QEMUFile *f, void *pv, size_t size)
{
unsigned long *bmp = pv;
int i, idx = 0;
for (i = 0; i < BITS_TO_U64S(size); i++) {
uint64_t w = bmp[idx++];
if (sizeof(unsigned long) == 4 && idx < BITS_TO_LONGS(size)) {
w |= ((uint64_t)bmp[idx++]) << 32;
... | true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 |
3,828 | void run_on_cpu(CPUState *env, void (*func)(void *data), void *data)
{
func(data);
}
| true | qemu | 12d4536f7d911b6d87a766ad7300482ea663cea2 |
3,829 | static int dirac_decode_picture_header(DiracContext *s)
{
unsigned retire, picnum;
int i, j, ret;
int64_t refdist, refnum;
GetBitContext *gb = &s->gb;
/* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
picnum = s->current_picture->avframe->display_picture_number = get... | true | FFmpeg | db79dedb1ae5dd38432eee3f09155e26f3f2d95a |
3,830 | static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
{
int ret = 0, i;
int got_output = 0;
AVPacket avpkt;
if (!ist->saw_first_ts) {
ist->dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
... | true | FFmpeg | 8f6f2322285fc14f8f16377db50355864019a757 |
3,831 | static int interleave_new_audio_packet(AVFormatContext *s, AVPacket *pkt,
int stream_index, int flush)
{
AVStream *st = s->streams[stream_index];
AudioInterleaveContext *aic = st->priv_data;
int size = FFMIN(av_fifo_size(aic->fifo), *aic->samples * aic->sample_s... | false | FFmpeg | 1967cd4e4c1cd96dfa195ce14e4b212ddb70586d |
3,833 | static void memcard_write(void *opaque, target_phys_addr_t addr, uint64_t value,
unsigned size)
{
MilkymistMemcardState *s = opaque;
trace_milkymist_memcard_memory_write(addr, value);
addr >>= 2;
switch (addr) {
case R_PENDING:
/* clear rx pending bits *... | false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
3,835 | static uint32_t arm_v7m_load_vector(ARMCPU *cpu)
{
CPUState *cs = CPU(cpu);
CPUARMState *env = &cpu->env;
MemTxResult result;
hwaddr vec = env->v7m.vecbase + env->v7m.exception * 4;
uint32_t addr;
addr = address_space_ldl(cs->as, vec,
MEMTXATTRS_UNSPECIFIED... | false | qemu | 45db7ba681ede57113a67499840e69ee586bcdf2 |
3,836 | static gboolean serial_xmit(GIOChannel *chan, GIOCondition cond, void *opaque)
{
SerialState *s = opaque;
if (s->tsr_retry <= 0) {
if (s->fcr & UART_FCR_FE) {
s->tsr = fifo8_is_full(&s->xmit_fifo) ?
0 : fifo8_pop(&s->xmit_fifo);
if (!s->xmit_fifo.... | false | qemu | 88c1ee73d3231c74ff90bcfc084a7589670ec244 |
3,837 | ssize_t nbd_send_request(QIOChannel *ioc, NBDRequest *request)
{
uint8_t buf[NBD_REQUEST_SIZE];
TRACE("Sending request to server: "
"{ .from = %" PRIu64", .len = %" PRIu32 ", .handle = %" PRIu64
", .flags = %" PRIx16 ", .type = %" PRIu16 " }",
request->from, request->len, r... | false | qemu | d1fdf257d52822695f5ace6c586e059aa17d4b79 |
3,839 | static AVFilterContext *create_filter(AVFilterGraph *ctx, int index,
const char *name, const char *args,
AVClass *log_ctx)
{
AVFilterContext *filt;
AVFilter *filterdef;
char inst_name[30];
snprintf(inst_name, sizeof(i... | false | FFmpeg | 5e600185453e1a0ded70a59701f60a0022a88e42 |
3,840 | static void scsi_dma_complete_noio(void *opaque, int ret)
{
SCSIDiskReq *r = (SCSIDiskReq *)opaque;
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
if (r->req.aiocb != NULL) {
r->req.aiocb = NULL;
block_acct_done(bdrv_get_stats(s->qdev.conf.bs), &r->acct);
}
... | false | qemu | 3df9caf88f5c0859ae380101fea47609ba1dbfbd |
3,841 | int vnc_display_password(DisplayState *ds, const char *password)
{
VncDisplay *vs = vnc_display;
if (!vs) {
return -EINVAL;
}
if (!password) {
/* This is not the intention of this interface but err on the side
of being safe */
return vnc_display_disable_lo... | false | qemu | cf864569cd9134ee503ad9eb6be2881001c0ed80 |
3,842 | START_TEST(qdict_get_str_test)
{
const char *p;
const char *key = "key";
const char *str = "string";
qdict_put(tests_dict, key, qstring_from_str(str));
p = qdict_get_str(tests_dict, key);
fail_unless(p != NULL);
fail_unless(strcmp(p, str) == 0);
}
| false | qemu | ac531cb6e542b1e61d668604adf9dc5306a948c0 |
3,843 | static void rtas_set_tce_bypass(sPAPREnvironment *spapr, uint32_t token,
uint32_t nargs, target_ulong args,
uint32_t nret, target_ulong rets)
{
VIOsPAPRBus *bus = spapr->vio_bus;
VIOsPAPRDevice *dev;
uint32_t unit, enable;
if (narg... | false | qemu | 210b580b106fa798149e28aa13c66b325a43204e |
3,844 | void uuid_generate(uuid_t out)
{
memset(out, 0, sizeof(uuid_t));
}
| false | qemu | 8ba2aae32c40f544def6be7ae82be9bcb781e01d |
3,846 | static void test_unaligned_write_same(void)
{
QVirtIOSCSI *vs;
uint8_t buf[512] = { 0 };
const uint8_t write_same_cdb[CDB_SIZE] = { 0x41, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x02, 0x00 };
qvirtio_scsi_start("-drive file=blkdebug::null-co://,if... | false | qemu | 4bb7b0daf8ea34bcc582642d35a2e4902f7841db |
3,847 | static void *spapr_build_fdt(sPAPRMachineState *spapr,
hwaddr rtas_addr,
hwaddr rtas_size)
{
MachineState *machine = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(machine);
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(ma... | false | qemu | ffbb1705a33df8e2fb12b24d96663d63b22eaf8b |
3,848 | static void cpu_unlink_tb(CPUState *env)
{
#if defined(CONFIG_USE_NPTL)
/* FIXME: TB unchaining isn't SMP safe. For now just ignore the
problem and hope the cpu will stop of its own accord. For userspace
emulation this often isn't actually as bad as it sounds. Often
signals are used pr... | false | qemu | f76cfe56d9bc281685c5120bf765d29d9323756f |
3,849 | void ppc_hash64_store_hpte(PowerPCCPU *cpu, hwaddr ptex,
uint64_t pte0, uint64_t pte1)
{
CPUPPCState *env = &cpu->env;
hwaddr offset = ptex * HASH_PTE_SIZE_64;
if (env->external_htab == MMU_HASH64_KVM_MANAGED_HPT) {
kvmppc_write_hpte(ptex, pte0, pte1);
ret... | false | qemu | e57ca75ce3b2bd33102573a8c0555d62e1bcfceb |
3,850 | static int get_last_needed_nal(H264Context *h)
{
int nals_needed = 0;
int i;
for (i = 0; i < h->pkt.nb_nals; i++) {
H2645NAL *nal = &h->pkt.nals[i];
GetBitContext gb;
/* packets can sometimes contain multiple PPS/SPS,
* e.g. two PAFF field pictures in one packet,... | false | FFmpeg | 5c2fb561d94fc51d76ab21d6f7cc5b6cc3aa599c |
3,851 | static void *qemu_tcg_rr_cpu_thread_fn(void *arg)
{
CPUState *cpu = arg;
rcu_register_thread();
qemu_mutex_lock_iothread();
qemu_thread_get_self(cpu->thread);
CPU_FOREACH(cpu) {
cpu->thread_id = qemu_get_thread_id();
cpu->created = true;
cpu->can_do_io = 1;
... | false | qemu | 6b8f0187a4d7c263e356302f8d308655372a4b5b |
3,852 | static QPCIDevice *start_ahci_device(QPCIDevice *ahci, void **hba_base)
{
/* Map AHCI's ABAR (BAR5) */
*hba_base = qpci_iomap(ahci, 5, NULL);
/* turns on pci.cmd.iose, pci.cmd.mse and pci.cmd.bme */
qpci_device_enable(ahci);
return ahci;
}
| false | qemu | c2f3029fbc5e7beb4cfb7ac264e10838fada524e |
3,853 | static DriveInfo *blockdev_init(const char *file, QDict *bs_opts,
BlockInterfaceType type,
Error **errp)
{
const char *buf;
const char *serial;
int ro = 0;
int bdrv_flags = 0;
int on_read_error, on_write_error;
DriveInfo *d... | false | qemu | ee13ed1cbc5f7f848e417f587c93ca1f36d83eb0 |
3,854 | static void tcp_chr_connect(void *opaque)
{
CharDriverState *chr = opaque;
TCPCharDriver *s = chr->opaque;
struct sockaddr_storage ss, ps;
socklen_t ss_len = sizeof(ss), ps_len = sizeof(ps);
memset(&ss, 0, ss_len);
if (getsockname(s->fd, (struct sockaddr *) &ss, &ss_len) != 0) {
... | false | qemu | 0ff0fad23d3693ecf7a0c462cdb48f0e60f93808 |
3,855 | static inline int get_bat(CPUPPCState *env, mmu_ctx_t *ctx,
target_ulong virtual, int rw, int type)
{
target_ulong *BATlt, *BATut, *BATu, *BATl;
target_ulong BEPIl, BEPIu, bl;
int i, valid, prot;
int ret = -1;
LOG_BATS("%s: %cBAT v " TARGET_FMT_lx "\n", __func__,
... | false | qemu | 629bd516fda67c95ba1c7d1393bacb9e68ea0712 |
3,856 | static void ehci_flush_qh(EHCIQueue *q)
{
uint32_t *qh = (uint32_t *) &q->qh;
uint32_t dwords = sizeof(EHCIqh) >> 2;
uint32_t addr = NLPTR_GET(q->qhaddr);
put_dwords(addr + 3 * sizeof(uint32_t), qh + 3, dwords - 3);
}
| false | qemu | 68d553587c0aa271c3eb2902921b503740d775b6 |
3,857 | static void v9fs_statfs(void *opaque)
{
int32_t fid;
ssize_t retval = 0;
size_t offset = 7;
V9fsFidState *fidp;
struct statfs stbuf;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
pdu_unmarshal(pdu, offset, "d", &fid);
fidp = get_fid(pdu, fid);
if (fidp == NULL) {
... | false | qemu | ddca7f86ac022289840e0200fd4050b2b58e9176 |
3,860 | static enum AVPixelFormat get_chroma_format(SchroChromaFormat schro_pix_fmt)
{
int num_formats = sizeof(schro_pixel_format_map) /
sizeof(schro_pixel_format_map[0]);
int idx;
for (idx = 0; idx < num_formats; ++idx)
if (schro_pixel_format_map[idx].schro_pix_fmt == schro_p... | true | FFmpeg | 220b24c7c97dc033ceab1510549f66d0e7b52ef1 |
3,861 | static void disas_uncond_b_reg(DisasContext *s, uint32_t insn)
{
unsigned int opc, op2, op3, rn, op4;
opc = extract32(insn, 21, 4);
op2 = extract32(insn, 16, 5);
op3 = extract32(insn, 10, 6);
rn = extract32(insn, 5, 5);
op4 = extract32(insn, 0, 5);
if (op4 != 0x0 || op3 != 0x0 ||... | true | qemu | 52e60cdd342dc48116edb81b443ba8c0a0c6f1a3 |
3,862 | static uint32_t openpic_cpu_read_internal(void *opaque, hwaddr addr,
int idx)
{
OpenPICState *opp = opaque;
IRQ_src_t *src;
IRQ_dst_t *dst;
uint32_t retval;
int n_IRQ;
DPRINTF("%s: cpu %d addr " TARGET_FMT_plx "\n", __func__, idx, addr);
r... | true | qemu | af7e9e74c6a62a5bcd911726a9e88d28b61490e0 |
3,863 | static const unsigned char *seq_decode_op3(SeqVideoContext *seq, const unsigned char *src, unsigned char *dst)
{
int pos, offset;
do {
pos = *src++;
offset = ((pos >> 3) & 7) * seq->frame.linesize[0] + (pos & 7);
dst[offset] = *src++;
} while (!(pos & 0x80));
return s... | true | FFmpeg | 5d7e3d71673d64a16b58430a0027afadb6b3a54e |
3,864 | static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
{
Vp3DecodeContext *s = avctx->priv_data;
int visible_width, visible_height, colorspace;
int offset_x = 0, offset_y = 0;
AVRational fps, aspect;
s->theora = get_bits_long(gb, 24);
av_log(avctx, AV_LOG_DEBUG, "Theo... | true | FFmpeg | a56d963f111b1a192cdabb05500f8083bd77ca93 |
3,865 | static int cdxl_read_packet(AVFormatContext *s, AVPacket *pkt)
{
CDXLDemuxContext *cdxl = s->priv_data;
AVIOContext *pb = s->pb;
uint32_t current_size, video_size, image_size;
uint16_t audio_size, palette_size, width, height;
int64_t pos;
int ret;
if (pb->eof_reached)
... | true | FFmpeg | d7804de351da059bf0c41c2bc2bbc02dbb755c0f |
3,866 | static ssize_t gem_receive(NetClientState *nc, const uint8_t *buf, size_t size)
{
CadenceGEMState *s;
unsigned rxbufsize, bytes_to_copy;
unsigned rxbuf_offset;
uint8_t rxbuf[2048];
uint8_t *rxbuf_ptr;
bool first_desc = true;
int maf;
s = qemu_get_nic_opaque(nc);
... | true | qemu | 244381ec19ce1412b474f41b5f30fe1da846451b |
3,867 | static int mpegts_read_close(AVFormatContext *s)
{
MpegTSContext *ts = s->priv_data;
int i;
clear_programs(ts);
for(i=0;i<NB_PID_MAX;i++)
if (ts->pids[i]) mpegts_close_filter(ts, ts->pids[i]);
return 0;
}
| true | FFmpeg | a717f9904227d7979473bad40c50eb40af41d01d |
3,868 | int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
enum AVSampleFormat sample_fmt, int align)
{
int line_size;
int sample_size = av_get_bytes_per_sample(sample_fmt);
int planar = av_sample_fmt_is_planar(sample_fmt);
/* validate para... | true | FFmpeg | 0e830094ad0dc251613a0aa3234d9c5c397e02e6 |
3,869 | int pt_setxattr(FsContext *ctx, const char *path, const char *name, void *value,
size_t size, int flags)
{
char *buffer;
int ret;
buffer = rpath(ctx, path);
ret = lsetxattr(buffer, name, value, size, flags);
g_free(buffer);
return ret;
}
| true | qemu | 3e36aba757f76673007a80b3cd56a4062c2e3462 |
3,870 | static void gen_b(DisasContext *ctx)
{
target_ulong li, target;
ctx->exception = POWERPC_EXCP_BRANCH;
/* sign extend LI */
#if defined(TARGET_PPC64)
if (ctx->sf_mode)
li = ((int64_t)LI(ctx->opcode) << 38) >> 38;
else
#endif
li = ((int32_t)LI(ctx->opcode) << 6) >> 6;
... | true | qemu | 697ab892786d47008807a49f57b2fd86adfcd098 |
3,871 | bool qdict_get_bool(const QDict *qdict, const char *key)
{
QObject *obj = qdict_get_obj(qdict, key, QTYPE_QBOOL);
return qbool_get_bool(qobject_to_qbool(obj));
}
| true | qemu | 14b6160099f0caf5dc9d62e637b007bc5d719a96 |
3,872 | static void adx_encode(unsigned char *adx,const short *wav,
ADXChannelState *prev)
{
int scale;
int i;
int s0,s1,s2,d;
int max=0;
int min=0;
int data[32];
s1 = prev->s1;
s2 = prev->s2;
for(i=0;i<32;i++) {
s0 = wav[i];
d = ((s0<<14... | true | FFmpeg | 954d94dd5e13ba7a5e9e049d0f980bddced9644c |
3,874 | static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs,
BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
int64_t align, QEMUIOVector *qiov, int flags)
{
BlockDriver *drv = bs->drv;
bool waited;
int ret;
int64_t start_sector = offset >> BDRV_SECTOR_BITS;
int64... | true | qemu | 3ff2f67a7c24183fcbcfe1332e5223ac6f96438c |
3,875 | int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
const void *pp, unsigned pp_size,
const void *qm, unsigned qm_size,
int (*commit_bs_si)(AVCodecContext *,
D... | false | FFmpeg | 70143a3954e1c4412efb2bf1a3a818adea2d3abf |
3,876 | static void put_no_rnd_pixels_x2_mmx( UINT8 *block, const UINT8 *pixels, int line_size, int h)
{
UINT8 *p;
const UINT8 *pix;
p = block;
pix = pixels;
MOVQ_ZERO(mm7);
do {
__asm __volatile(
"movq %1, %%mm0\n\t"
"movq 1%1, %%mm1\n\t"
"movq %%mm0, %%mm2\n\t"
"movq %%mm1, %%mm3\n\t"
"p... | false | FFmpeg | 91abb473fb8432226918da4fe03365ebaf688978 |
3,877 | static int attribute_align_arg av_buffersrc_add_frame_internal(AVFilterContext *ctx,
AVFrame *frame, int flags)
{
BufferSourceContext *s = ctx->priv;
AVFrame *copy;
int ret;
if (!frame) {
s->eof = 1;
return 0;
... | false | FFmpeg | f29c28a884c01ea63559fd6bc2250a6b5f78cbb0 |
3,878 | static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
{
AVPacket pkt1, *pkt = &pkt1;
AVStream *st;
int read_size, i, ret;
int64_t end_time;
int64_t filesize, offset, duration;
/* free previous packet */
if (ic->cur_st && ic->cur_st->parser)
av_... | true | FFmpeg | cc5297e871f2a30b62b972c6479ab1d4fdc14132 |
3,879 | static int matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data,
int size, int64_t pos, uint64_t cluster_time,
uint64_t block_duration, int is_keyframe,
int64_t cluster_pos)
{
uint64_t timecode = AV_NO... | true | FFmpeg | 25a80a931a3829f9d730971dbd269aa39cc273f6 |
3,880 | GAChannel *ga_channel_new(GAChannelMethod method, const gchar *path,
GAChannelCallback cb, gpointer opaque)
{
GAChannel *c = g_malloc0(sizeof(GAChannel));
SECURITY_ATTRIBUTES sec_attrs;
if (!ga_channel_open(c, method, path)) {
g_critical("error opening channel");
... | true | qemu | f3a06403b82c7f036564e4caf18b52ce6885fcfb |
3,881 | static void coroutine_fn verify_entered_step_2(void *opaque)
{
Coroutine *caller = (Coroutine *)opaque;
g_assert(qemu_coroutine_entered(caller));
g_assert(qemu_coroutine_entered(qemu_coroutine_self()));
qemu_coroutine_yield();
/* Once more to check it still works after yielding */
g_a... | true | qemu | 6b2fef739127ee6135d5ccc2da0bf1f3bebf66b7 |
3,882 | static void mirror_complete(BlockJob *job, Error **errp)
{
MirrorBlockJob *s = container_of(job, MirrorBlockJob, common);
int ret;
ret = bdrv_open_backing_file(s->target);
if (ret < 0) {
char backing_filename[PATH_MAX];
bdrv_get_full_backing_filename(s->target, backing_filename,... | true | qemu | 31ca6d077c24b7aaa322d8930e3e5debbdb4a047 |
3,883 | decode_cabac_residual_internal(const H264Context *h, H264SliceContext *sl,
int16_t *block,
int cat, int n, const uint8_t *scantable,
const uint32_t *qmul, int max_coeff,
int is_dc, int chroma4... | true | FFmpeg | a3a408259912e6d9337837c5d63c4b826778530f |
3,884 | static int opus_header(AVFormatContext *avf, int idx)
{
struct ogg *ogg = avf->priv_data;
struct ogg_stream *os = &ogg->streams[idx];
AVStream *st = avf->streams[idx];
struct oggopus_private *priv = os->private;
uint8_t *packet = os->buf + os->p... | true | FFmpeg | a3a0b5bd0aaae314619d5b41fb918aacd908a5ae |
3,885 | av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
SwsFilter *dstFilter)
{
int i;
int usesVFilter, usesHFilter;
int unscaled;
SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
int srcW = c->srcW;
int srcH = c->srcH;
... | true | FFmpeg | 5e3f6dc70198426fe0741e3017826b8bf3ee5ad8 |
3,886 | static int spapr_vio_busdev_init(DeviceState *qdev)
{
VIOsPAPRDevice *dev = (VIOsPAPRDevice *)qdev;
VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
char *id;
if (dev->reg != -1) {
/*
* Explicitly assigned address, just verify that no-one else
* is using it.... | true | qemu | ad0ebb91cd8b5fdc4a583b03645677771f420a46 |
3,887 | static void generate_joint_tables(HYuvContext *s)
{
uint16_t symbols[1 << VLC_BITS];
uint16_t bits[1 << VLC_BITS];
uint8_t len[1 << VLC_BITS];
if (s->bitstream_bpp < 24) {
int p, i, y, u;
for (p = 0; p < 3; p++) {
for (i = y = 0; y < 256; y++) {
int l... | true | FFmpeg | d0393d79bc3d61c9f2ff832c0e273b7774ff0269 |
3,888 | static DeviceState *slavio_intctl_init(target_phys_addr_t addr,
target_phys_addr_t addrg,
qemu_irq **parent_irq)
{
DeviceState *dev;
SysBusDevice *s;
unsigned int i, j;
dev = qdev_create(NULL, "slavio_intctl");
q... | true | qemu | e23a1b33b53d25510320b26d9f154e19c6c99725 |
3,889 | static int stellaris_enet_load(QEMUFile *f, void *opaque, int version_id)
{
stellaris_enet_state *s = (stellaris_enet_state *)opaque;
int i;
if (version_id != 1)
return -EINVAL;
s->ris = qemu_get_be32(f);
s->im = qemu_get_be32(f);
s->rctl = qemu_get_be32(f);
s->tctl = qe... | true | qemu | 2e1198672759eda6e122ff38fcf6df06f27e0fe2 |
3,890 | AudioState *AUD_init (void)
{
size_t i;
int done = 0;
const char *drvname;
AudioState *s = &glob_audio_state;
LIST_INIT (&s->hw_head_out);
LIST_INIT (&s->hw_head_in);
LIST_INIT (&s->cap_head);
atexit (audio_atexit);
s->ts = qemu_new_timer (vm_clock, audio_timer, s);
... | true | qemu | 0d9acba8fddbf970c7353083e6a60b47017ce3e4 |
3,891 | static void s390_cpu_model_initfn(Object *obj)
{ | true | qemu | ad5afd07b628cd0610ea322ad60b5ad03aa250c8 |
3,892 | static void spapr_finalize_fdt(sPAPREnvironment *spapr,
target_phys_addr_t fdt_addr,
target_phys_addr_t rtas_addr,
target_phys_addr_t rtas_size)
{
int ret;
void *fdt;
sPAPRPHBState *phb;
fdt = g_malloc... | true | qemu | 7f763a5d994bbddb50705d2e50decdf52937521f |
3,893 | void ff_check_pixfmt_descriptors(void){
int i, j;
for (i=0; i<FF_ARRAY_ELEMS(av_pix_fmt_descriptors); i++) {
const AVPixFmtDescriptor *d = &av_pix_fmt_descriptors[i];
uint8_t fill[4][8+6+3] = {{0}};
uint8_t *data[4] = {fill[0], fill[1], fill[2], fill[3]};
int linesize[4] ... | true | FFmpeg | f3ba91a3f1d9e99aebfe22278b0633f996e3fbe1 |
3,894 | static void disas_thumb_insn(CPUState *env, DisasContext *s)
{
uint32_t val, insn, op, rm, rn, rd, shift, cond;
int32_t offset;
int i;
TCGv tmp;
TCGv tmp2;
TCGv addr;
if (s->condexec_mask) {
cond = s->condexec_cond;
if (cond != 0x0e) { /* Skip conditional when... | true | qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 |
3,895 | int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
{
BDRVQcowState *s = bs->opaque;
QCowSnapshot *sn;
int i, snapshot_index, l1_size2;
snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);
if (snapshot_index < 0)
return -ENOENT;
sn = &s->snapshots[s... | true | qemu | 8b3b720620a1137a1b794fc3ed64734236f94e06 |
3,896 | static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops)
{
struct XenDevice *xendev;
char path[XEN_BUFSIZE], token[XEN_BUFSIZE];
char **dev = NULL, *dom0;
unsigned int cdev, j;
/* setup watch */
dom0 = xs_get_domain_path(xenstore, 0);
snprintf(token, sizeof(token)... | true | qemu | 33876dfad64bc481f59c5e9ccf60db78624c4b93 |
3,897 | static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
int point_transform, int nb_components)
{
int i, mb_x, mb_y, mask;
int bits= (s->bits+7)&~7;
int resync_mb_y = 0;
int resync_mb_x = 0;
point_transform += bits - s->bits;
mask = ((1 <... | true | FFmpeg | 4b72d5cd6f9341dcafdbc1b9030166aa987b8304 |
3,898 | inline static int push_frame(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = ctx->inputs[0];
ShowWavesContext *showwaves = outlink->src->priv;
int nb_channels = inlink->channels;
int ret, i;
if ((ret = ff_filter_frame(outlink, showwaves->outpicref)) ... | true | FFmpeg | 86476c510ebd14d33ed02289d71bae874f8707a4 |
3,899 | static void virtio_blk_handle_scsi(VirtIOBlockReq *req)
{
int status;
status = virtio_blk_handle_scsi_req(req->dev, req->elem);
virtio_blk_req_complete(req, status);
virtio_blk_free_request(req);
}
| true | qemu | f897bf751fbd95e4015b95d202c706548586813a |
3,900 | static int generate_fake_vps(QSVEncContext *q, AVCodecContext *avctx)
{
GetByteContext gbc;
PutByteContext pbc;
GetBitContext gb;
H2645NAL sps_nal = { NULL };
HEVCSPS sps = { 0 };
HEVCVPS vps = { 0 };
uint8_t vps_buf[128], vps_rbsp_buf[128];
uint8_t *new_extradata;
unsign... | false | FFmpeg | cc13bc8c4f0f4afa30d0b94c3f3a369ccd2aaf0b |
3,902 | static int qcelp_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
QCELPContext *q = avctx->priv_data;
float *outbuffer = data;
int i;
float quantized_lspf[10], ... | false | FFmpeg | e43dd3d2a8e106169e707484090a2d973ece2184 |
3,903 | int avio_read(AVIOContext *s, unsigned char *buf, int size)
{
int len, size1;
size1 = size;
while (size > 0) {
len = FFMIN(s->buf_end - s->buf_ptr, size);
if (len == 0 || s->write_flag) {
if((s->direct || size > s->buffer_size) && !s->update_checksum) {
... | false | FFmpeg | a606f27f4c610708fa96e35eed7b7537d3d8f712 |
3,904 | static int hls_probe(AVProbeData *p)
{
/* Require #EXTM3U at the start, and either one of the ones below
* somewhere for a proper match. */
if (strncmp(p->buf, "#EXTM3U", 7))
return 0;
if (p->filename && !av_match_ext(p->filename, "m3u8,m3u"))
return 0;
if (strstr(p->buf... | false | FFmpeg | cde57eee98d2e26daeeb1ba0cdd1f3d3acb3eb8a |
3,905 | static int svq1_motion_inter_block(MpegEncContext *s, GetBitContext *bitbuf,
uint8_t *current, uint8_t *previous,
int pitch, svq1_pmv *motion, int x, int y)
{
uint8_t *src;
uint8_t *dst;
svq1_pmv mv;
svq1_pmv *pmv[3];
int ... | false | FFmpeg | 7b9fc769e40a7709fa59a54e2a810f76364eee4b |
3,906 | int opt_default(void *optctx, const char *opt, const char *arg)
{
const AVOption *o;
int consumed = 0;
char opt_stripped[128];
const char *p;
const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
#if CONFIG_AVRESAMPLE
const AVClass *rc = avresample_get_class();
#endif
... | false | FFmpeg | 254c64c574dfc427721942fa84e4d24d6b6cc4c2 |
3,908 | static void usb_xhci_realize(struct PCIDevice *dev, Error **errp)
{
int i, ret;
Error *err = NULL;
XHCIState *xhci = XHCI(dev);
dev->config[PCI_CLASS_PROG] = 0x30; /* xHCI */
dev->config[PCI_INTERRUPT_PIN] = 0x01; /* interrupt pin 1 */
dev->config[PCI_CACHE_LINE_SIZE] = 0x10;
... | true | qemu | 20729dbd0109b9d9065447dba354f10bcf78d0d6 |
3,910 | int fw_cfg_add_file(FWCfgState *s, const char *filename, uint8_t *data,
uint32_t len)
{
int i, index;
if (!s->files) {
int dsize = sizeof(uint32_t) + sizeof(FWCfgFile) * FW_CFG_FILE_SLOTS;
s->files = g_malloc0(dsize);
fw_cfg_add_bytes(s, FW_CFG_FILE_DIR, (ui... | true | qemu | 4cad3867b6df2c0826ae508a9fe15dd0b9d8936a |
3,911 | static void *postcopy_ram_fault_thread(void *opaque)
{
MigrationIncomingState *mis = opaque;
struct uffd_msg msg;
int ret;
RAMBlock *rb = NULL;
RAMBlock *last_rb = NULL; /* last RAMBlock we sent part of */
trace_postcopy_ram_fault_thread_entry();
qemu_sem_post(&mis->fault_thread_se... | true | qemu | 3be98be4e9f59055afb5f2b27f9296c7093b4e75 |
3,912 | static ssize_t qio_channel_websock_decode_header(QIOChannelWebsock *ioc,
Error **errp)
{
unsigned char opcode, fin, has_mask;
size_t header_size;
size_t payload_len;
QIOChannelWebsockHeader *header =
(QIOChannelWebsockHeader *)ioc->encinput... | true | qemu | eefa3d8ef649f9055611361e2201cca49f8c3433 |
3,914 | static int vscsi_send_iu(VSCSIState *s, vscsi_req *req,
uint64_t length, uint8_t format)
{
long rc, rc1;
/* First copy the SRP */
rc = spapr_vio_dma_write(&s->vdev, req->crq.s.IU_data_ptr,
&req->iu, length);
if (rc) {
fprintf(stderr... | true | qemu | 22956a3755749b9cf6375ad024d58c1d277100bf |
3,915 | static int r3d_read_reda(AVFormatContext *s, AVPacket *pkt, Atom *atom)
{
AVStream *st = s->streams[1];
int av_unused tmp, tmp2;
int samples, size;
uint64_t pos = avio_tell(s->pb);
unsigned dts;
int ret;
dts = avio_rb32(s->pb);
st->codec->sample_rate = avio_rb32(s->pb);
... | true | FFmpeg | df92ac18528bac4566fc4f5ba4d607c1265791ea |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.