AV_RL32           755 fftools/ffmpeg.c         ost->quality = sd ? AV_RL32(sd) : -1;
AV_RL32           804 fftools/ffmpeg_opt.c                 tag = AV_RL32(codec_tag);
AV_RL32          1544 fftools/ffmpeg_opt.c             tag = AV_RL32(codec_tag);
AV_RL32          1905 fftools/ffprobe.c             print_int("skip_samples",    AV_RL32(sd->data));
AV_RL32          1906 fftools/ffprobe.c             print_int("discard_padding", AV_RL32(sd->data + 4));
AV_RL32            92 libavcodec/012v.c             t = AV_RL32(src);
AV_RL32           101 libavcodec/012v.c             t = AV_RL32(src);
AV_RL32           110 libavcodec/012v.c             t = AV_RL32(src);
AV_RL32           119 libavcodec/012v.c             t = AV_RL32(src);
AV_RL32           446 libavcodec/4xm.c         bitstream_size  = AV_RL32(buf + 8);
AV_RL32           447 libavcodec/4xm.c         wordstream_size = AV_RL32(buf + 12);
AV_RL32           448 libavcodec/4xm.c         bytestream_size = AV_RL32(buf + 16);
AV_RL32           775 libavcodec/4xm.c     const unsigned int bitstream_size = AV_RL32(buf);
AV_RL32           787 libavcodec/4xm.c     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
AV_RL32           848 libavcodec/4xm.c     if (buf_size < AV_RL32(buf + 4) + 8) {
AV_RL32           850 libavcodec/4xm.c                buf_size, AV_RL32(buf + 4));
AV_RL32           854 libavcodec/4xm.c     frame_4cc = AV_RL32(buf);
AV_RL32           856 libavcodec/4xm.c     if (frame_4cc == AV_RL32("cfrm")) {
AV_RL32           867 libavcodec/4xm.c         id         = AV_RL32(buf + 12);
AV_RL32           868 libavcodec/4xm.c         whole_size = AV_RL32(buf + 16);
AV_RL32           919 libavcodec/4xm.c             frame_4cc  = AV_RL32("pfrm");
AV_RL32           930 libavcodec/4xm.c     if (frame_4cc == AV_RL32("ifr2")) {
AV_RL32           936 libavcodec/4xm.c     } else if (frame_4cc == AV_RL32("ifrm")) {
AV_RL32           942 libavcodec/4xm.c     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
AV_RL32           948 libavcodec/4xm.c     } else if (frame_4cc == AV_RL32("snd_")) {
AV_RL32          1013 libavcodec/4xm.c     f->version = AV_RL32(avctx->extradata) >> 16;
AV_RL32           247 libavcodec/a64multienc.c          avctx->codec_tag = AV_RL32("a64m");
AV_RL32            58 libavcodec/aasc.c             s->palette[i] = 0xFFU << 24 | AV_RL32(ptr);
AV_RL32            97 libavcodec/aasc.c     compr     = AV_RL32(buf);
AV_RL32           160 libavcodec/adpcm.c             c->status[0].predictor = av_clip_intp2(AV_RL32(avctx->extradata    ), 18);
AV_RL32           161 libavcodec/adpcm.c             c->status[1].predictor = av_clip_intp2(AV_RL32(avctx->extradata + 4), 18);
AV_RL32           166 libavcodec/adpcm.c             c->status[0].predictor  = av_clip_intp2(AV_RL32(avctx->extradata +  0), 18);
AV_RL32           167 libavcodec/adpcm.c             c->status[0].step_index = av_clip(AV_RL32(avctx->extradata +  4), 0, 88);
AV_RL32           168 libavcodec/adpcm.c             c->status[1].predictor  = av_clip_intp2(AV_RL32(avctx->extradata +  8), 18);
AV_RL32           169 libavcodec/adpcm.c             c->status[1].step_index = av_clip(AV_RL32(avctx->extradata + 12), 0, 88);
AV_RL32           337 libavcodec/asvenc.c     ((uint32_t *) avctx->extradata)[1] = av_le2ne32(AV_RL32("ASUS"));
AV_RL32           862 libavcodec/atrac9dec.c     version = AV_RL32(avctx->extradata);
AV_RL32          1355 libavcodec/bink.c     flags = AV_RL32(avctx->extradata);
AV_RL32            88 libavcodec/bytestream.h DEF(unsigned int, le32, 4, AV_RL32, AV_WL32)
AV_RL32           657 libavcodec/clearvideo.c         c->tile_size = AV_RL32(&avctx->extradata[94]);
AV_RL32           389 libavcodec/cllc.c     info_tag    = AV_RL32(src);
AV_RL32           391 libavcodec/cllc.c         info_offset = AV_RL32(src + 4);
AV_RL32           429 libavcodec/cllc.c     coding_type = (AV_RL32(src) >> 8) & 0xFF;
AV_RL32           392 libavcodec/decode.c             avci->skip_samples = AV_RL32(side) * avci->skip_samples_multiplier;
AV_RL32           393 libavcodec/decode.c             discard_padding = AV_RL32(side + 4);
AV_RL32            48 libavcodec/dpx.c         temp = AV_RL32(*ptr);
AV_RL32           151 libavcodec/dpx.c     if (magic_num == AV_RL32("SDPX")) {
AV_RL32           274 libavcodec/dv_profile.c         (stype == 31 && codec && codec->codec_tag==AV_RL32("SL25") && codec->coded_width==720 && codec->coded_height==576))
AV_RL32           279 libavcodec/dv_profile.c        && (codec->codec_tag==AV_RL32("dvsd") || codec->codec_tag==AV_RL32("CDVC"))
AV_RL32           214 libavcodec/dxtory.c     cur_slice_size = AV_RL32(src + off);
AV_RL32           306 libavcodec/dxv.c             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32           310 libavcodec/dxv.c             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32           317 libavcodec/dxv.c                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32           326 libavcodec/dxv.c                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32           447 libavcodec/dxv.c     next = AV_RL32(src + endoffset);
AV_RL32           462 libavcodec/dxv.c         next = AV_RL32(src + offset);
AV_RL32           523 libavcodec/dxv.c             AV_WL32(dst, AV_RL32(dst - (8 + offset)));
AV_RL32           524 libavcodec/dxv.c             AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
AV_RL32           531 libavcodec/dxv.c             AV_WL32(dst, AV_RL32(dst - (8 + offset)));
AV_RL32           532 libavcodec/dxv.c             AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
AV_RL32           539 libavcodec/dxv.c             v = AV_RL32(tptr0);
AV_RL32           540 libavcodec/dxv.c             AV_WL32(dst, AV_RL32(tptr0));
AV_RL32           541 libavcodec/dxv.c             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
AV_RL32           543 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           549 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           572 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           595 libavcodec/dxv.c             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
AV_RL32           597 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           606 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           620 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           634 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           662 libavcodec/dxv.c             AV_WL32(dst + 4, AV_RL32(tptr0 + 4));
AV_RL32           663 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           669 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           680 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           691 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           712 libavcodec/dxv.c             AV_WL32(dst + 4, AV_RL32(&dst[-v + 4]));
AV_RL32           713 libavcodec/dxv.c             tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFFu) >> 24] = dst + 2;
AV_RL32           720 libavcodec/dxv.c         AV_WL32(dst, AV_RL32(dst - (8 + offset)));
AV_RL32           721 libavcodec/dxv.c         AV_WL32(dst + 4, AV_RL32(dst - (4 + offset)));
AV_RL32           771 libavcodec/dxv.c     tab1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFF) >> 24] = dst + 2;
AV_RL32           773 libavcodec/dxv.c     tab3[0x9E3779B1 * (AV_RL32(dst + 10) & 0xFFFFFF) >> 24] = dst + 10;
AV_RL32           818 libavcodec/dxv.c     table1[0x9E3779B1 * (AV_RL32(dst + 2) & 0xFFFFFF) >> 24] = dst + 2;
AV_RL32           887 libavcodec/dxv.c             prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
AV_RL32           890 libavcodec/dxv.c             prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
AV_RL32           915 libavcodec/dxv.c                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
AV_RL32           919 libavcodec/dxv.c                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
AV_RL32           923 libavcodec/dxv.c                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
AV_RL32           927 libavcodec/dxv.c                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
AV_RL32           948 libavcodec/dxv.c                 prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
AV_RL32           952 libavcodec/dxv.c                 prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
AV_RL32           961 libavcodec/dxv.c                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32           965 libavcodec/dxv.c                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32           990 libavcodec/dxv.c             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32           994 libavcodec/dxv.c             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32          1003 libavcodec/dxv.c                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32          1012 libavcodec/dxv.c                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
AV_RL32           188 libavcodec/eacmv.c     if (AV_RL32(buf)==MVIh_TAG||AV_RB32(buf)==MVIh_TAG) {
AV_RL32           189 libavcodec/eacmv.c         unsigned size = AV_RL32(buf + 4);
AV_RL32           215 libavcodec/eatgq.c     big_endian = AV_RL32(&buf[4]) > 0x000FFFFF;
AV_RL32           278 libavcodec/eatgv.c     chunk_type = AV_RL32(&buf[0]);
AV_RL32          1018 libavcodec/exr.c         tile_x = AV_RL32(src - 20);
AV_RL32          1019 libavcodec/exr.c         tile_y = AV_RL32(src - 16);
AV_RL32          1020 libavcodec/exr.c         tile_level_x = AV_RL32(src - 12);
AV_RL32          1021 libavcodec/exr.c         tile_level_y = AV_RL32(src - 8);
AV_RL32          1023 libavcodec/exr.c         data_size = AV_RL32(src - 4);
AV_RL32          1061 libavcodec/exr.c         line = AV_RL32(src - 8);
AV_RL32          1066 libavcodec/exr.c         data_size = AV_RL32(src - 4);
AV_RL32           248 libavcodec/ffwavesynth.c     ws->nb_inter = AV_RL32(edata);
AV_RL32           261 libavcodec/ffwavesynth.c         in->type     = AV_RL32(edata + 16);
AV_RL32           262 libavcodec/ffwavesynth.c         in->channels = AV_RL32(edata + 20);
AV_RL32           275 libavcodec/ffwavesynth.c                 f1  = AV_RL32(edata +  0);
AV_RL32           276 libavcodec/ffwavesynth.c                 f2  = AV_RL32(edata +  4);
AV_RL32           277 libavcodec/ffwavesynth.c                 a1  = AV_RL32(edata +  8);
AV_RL32           278 libavcodec/ffwavesynth.c                 a2  = AV_RL32(edata + 12);
AV_RL32           279 libavcodec/ffwavesynth.c                 phi = AV_RL32(edata + 16);
AV_RL32           297 libavcodec/ffwavesynth.c                 a1  = AV_RL32(edata +  0);
AV_RL32           298 libavcodec/ffwavesynth.c                 a2  = AV_RL32(edata +  4);
AV_RL32           439 libavcodec/ffwavesynth.c     duration = AV_RL32(packet->data + 8);
AV_RL32           177 libavcodec/flac.c     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
AV_RL32           107 libavcodec/flicvideo.c             s->palette[i] = AV_RL32(ptr);
AV_RL32           157 libavcodec/fraps.c     header      = AV_RL32(buf);
AV_RL32           199 libavcodec/fraps.c         if (AV_RL32(buf) != FPS_TAG || buf_size < planes*1024 + 24) {
AV_RL32           204 libavcodec/fraps.c             offs[i] = AV_RL32(buf + 4 + i * 4);
AV_RL32           261 libavcodec/fraps.c                 pal[y] = AV_RL32(buf) | 0xFF000000;
AV_RL32           162 libavcodec/get_bits.h       AV_RL32((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
AV_RL32           237 libavcodec/get_bits.h         s->cache = (uint64_t)AV_RL32(s->buffer + (s->index >> 3)) << s->bits_left | s->cache;
AV_RL32           134 libavcodec/h263dec.c     if (avctx->codec_tag == AV_RL32("L263") || avctx->codec_tag == AV_RL32("S263"))
AV_RL32           706 libavcodec/h263dec.c             && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {
AV_RL32           420 libavcodec/hqx.c     info_tag    = AV_RL32(src);
AV_RL32           422 libavcodec/hqx.c         uint32_t info_offset = AV_RL32(src + 4);
AV_RL32          1229 libavcodec/huffyuvdec.c         (buf_size > 32 && AV_RL32(avpkt->data + buf_size - 16) == 0)) {
AV_RL32          1230 libavcodec/huffyuvdec.c         slices_info_offset = AV_RL32(avpkt->data + buf_size - 4);
AV_RL32          1231 libavcodec/huffyuvdec.c         slice_height = AV_RL32(avpkt->data + buf_size - 8);
AV_RL32          1232 libavcodec/huffyuvdec.c         nb_slices = AV_RL32(avpkt->data + buf_size - 12);
AV_RL32          1246 libavcodec/huffyuvdec.c             slice_offset = AV_RL32(avpkt->data + slices_info_offset + slice * 8);
AV_RL32          1247 libavcodec/huffyuvdec.c             slice_size = AV_RL32(avpkt->data + slices_info_offset + slice * 8 + 4);
AV_RL32            94 libavcodec/imm5.c     if (avpkt->size > 24 && avpkt->data[8] <= 1 && AV_RL32(avpkt->data + 4) + 24ULL <= avpkt->size) {
AV_RL32            97 libavcodec/imm5.c         int new_size = AV_RL32(avpkt->data + 4);
AV_RL32           667 libavcodec/ituh263dec.c     if (s->codec_tag == AV_RL32("U263") && p->f->pict_type == AV_PICTURE_TYPE_I) {
AV_RL32          1282 libavcodec/ituh263dec.c     if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){
AV_RL32           157 libavcodec/jvdec.c     video_size = AV_RL32(buf);
AV_RL32           408 libavcodec/kmvc.c             c->pal[i] = AV_RL32(src);
AV_RL32           453 libavcodec/lagarith.c         if (esc_count && AV_RL32(src + 1) < length) {
AV_RL32           454 libavcodec/lagarith.c             length = AV_RL32(src + 1);
AV_RL32           556 libavcodec/lagarith.c     offset_gu = AV_RL32(buf + 1);
AV_RL32           557 libavcodec/lagarith.c     offset_bv = AV_RL32(buf + 5);
AV_RL32           610 libavcodec/lagarith.c         offs[3] = AV_RL32(buf + 9);
AV_RL32           192 libavcodec/lcldec.c                 mthread_inlen = AV_RL32(buf);
AV_RL32           197 libavcodec/lcldec.c                 mthread_outlen = AV_RL32(buf + 4);
AV_RL32           267 libavcodec/lcldec.c             mthread_inlen = AV_RL32(buf);
AV_RL32           269 libavcodec/lcldec.c             mthread_outlen = AV_RL32(buf + 4);
AV_RL32            76 libavcodec/libcelt_dec.c         celt->discard = AV_RL32(c->extradata);
AV_RL32            84 libavcodec/libcelt_dec.c         unsigned version = AV_RL32(c->extradata + 4);
AV_RL32           673 libavcodec/libxvid.c             avctx->codec_tag = AV_RL32("xvid");
AV_RL32           293 libavcodec/loco.c     version = AV_RL32(avctx->extradata);
AV_RL32           299 libavcodec/loco.c         l->lossy = AV_RL32(avctx->extradata + 8);
AV_RL32           302 libavcodec/loco.c         l->lossy = AV_RL32(avctx->extradata + 8);
AV_RL32           311 libavcodec/loco.c     l->mode = AV_RL32(avctx->extradata + 4);
AV_RL32            61 libavcodec/m101.c     stride = AV_RL32(avctx->extradata + 5*4);
AV_RL32           285 libavcodec/metasound.c     tag = AV_RL32(avctx->extradata + 12);
AV_RL32            83 libavcodec/mjpega_dump_header_bsf.c                 if (i + 8 < in->size && AV_RL32(in->data + i + 8) == AV_RL32("mjpg")) {
AV_RL32           182 libavcodec/mjpegdec.c         if (avctx->codec_tag == AV_RL32("MJPG"))
AV_RL32           187 libavcodec/mjpegdec.c         && AV_RL32(avctx->extradata) == 0x2C
AV_RL32           188 libavcodec/mjpegdec.c         && AV_RL32(avctx->extradata+4) == 0x18) {
AV_RL32          1696 libavcodec/mjpegdec.c     if(s->avctx->codec_tag != AV_RL32("CJPG")){
AV_RL32          1940 libavcodec/mjpegdec.c     if (id == AV_RL32("colr") && len > 0) {
AV_RL32          1947 libavcodec/mjpegdec.c     if (id == AV_RL32("xfrm") && len > 0) {
AV_RL32          1060 libavcodec/mpeg12dec.c     if (   avctx->codec_tag != AV_RL32("VCR2")
AV_RL32          1061 libavcodec/mpeg12dec.c         && avctx->codec_tag != AV_RL32("BW10"))
AV_RL32          1743 libavcodec/mpeg12dec.c     if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
AV_RL32          2222 libavcodec/mpeg12dec.c     if (s->codec_tag == AV_RL32("BW10")) {
AV_RL32          2822 libavcodec/mpeg12dec.c     if (s->mpeg_enc_ctx_allocated == 0 && (   s2->codec_tag == AV_RL32("VCR2")
AV_RL32          2823 libavcodec/mpeg12dec.c                                            || s2->codec_tag == AV_RL32("BW10")
AV_RL32           190 libavcodec/mpeg4video.h #define IS_3IV1 s->codec_tag == AV_RL32("3IV1")
AV_RL32          2262 libavcodec/mpeg4videodec.c                 !(s->width && s->codec_tag == AV_RL32("MP4S"))) {
AV_RL32          2588 libavcodec/mpeg4videodec.c         if (s->codec_tag        == AV_RL32("XVID") ||
AV_RL32          2589 libavcodec/mpeg4videodec.c             s->codec_tag        == AV_RL32("XVIX") ||
AV_RL32          2590 libavcodec/mpeg4videodec.c             s->codec_tag        == AV_RL32("RMP4") ||
AV_RL32          2591 libavcodec/mpeg4videodec.c             s->codec_tag        == AV_RL32("ZMP4") ||
AV_RL32          2592 libavcodec/mpeg4videodec.c             s->codec_tag        == AV_RL32("SIPP"))
AV_RL32          2597 libavcodec/mpeg4videodec.c         if (s->codec_tag == AV_RL32("DIVX") && s->vo_type == 0 &&
AV_RL32          2607 libavcodec/mpeg4videodec.c         if (s->codec_tag == AV_RL32("XVIX"))
AV_RL32          2610 libavcodec/mpeg4videodec.c         if (s->codec_tag == AV_RL32("UMP4"))
AV_RL32          3244 libavcodec/mpeg4videodec.c     if (s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630) {
AV_RL32          3254 libavcodec/mpeg4videodec.c                 (ctx->divx_version >= 0 || ctx->xvid_build >= 0) || s->codec_tag == AV_RL32("QMP4")) {
AV_RL32           395 libavcodec/mpegvideo.c     if (s->avctx->codec_tag == AV_RL32("VCR2")) {
AV_RL32           477 libavcodec/mpegvideo.c     if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
AV_RL32           161 libavcodec/mscc.c                 s->pal[j] = 0xFF000000 | AV_RL32(pal + j * 4);
AV_RL32            78 libavcodec/msrle.c             s->pal[i] = 0xFFU<<24 | AV_RL32(avctx->extradata+4*i);
AV_RL32           162 libavcodec/mvha.c     size = AV_RL32(avpkt->data + 4);
AV_RL32            98 libavcodec/nuv.c         c->lq[i] = AV_RL32(buf);
AV_RL32           100 libavcodec/nuv.c         c->cq[i] = AV_RL32(buf);
AV_RL32          1443 libavcodec/pngdec.c         if (   !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG")
AV_RL32           270 libavcodec/pnmdec.c                     r[j] = av_int2float(AV_RL32(s->bytestream+0)) * scale;
AV_RL32           271 libavcodec/pnmdec.c                     g[j] = av_int2float(AV_RL32(s->bytestream+4)) * scale;
AV_RL32           272 libavcodec/pnmdec.c                     b[j] = av_int2float(AV_RL32(s->bytestream+8)) * scale;
AV_RL32            68 libavcodec/prores_metadata_bsf.c     if (AV_RL32(buf + 4) != AV_RL32("icpf")) {
AV_RL32           761 libavcodec/proresdec2.c     if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) {
AV_RL32           904 libavcodec/proresenc_anatoliy.c     avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
AV_RL32           158 libavcodec/prosumer.c     ret = decompress(&s->gb, AV_RL32(avpkt->data + 28) >> 1, &s->pb, s->lut);
AV_RL32           331 libavcodec/qpeg.c         a->pal[i] = 0xFFU<<24 | AV_RL32(pal_src+4*i);
AV_RL32           417 libavcodec/rasc.c                 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
AV_RL32           426 libavcodec/rasc.c                 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
AV_RL32           442 libavcodec/rasc.c                 v0 = AV_RL32(b2 + cx);
AV_RL32           443 libavcodec/rasc.c                 v1 = AV_RL32(b1 + cx);
AV_RL32           453 libavcodec/rasc.c                 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
AV_RL32           129 libavcodec/rawdec.c     if (avctx->codec_tag == AV_RL32("yuv2") &&
AV_RL32           450 libavcodec/rawdec.c     if (avctx->codec_tag == AV_RL32("I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
AV_RL32           455 libavcodec/rawdec.c     if (avctx->codec_tag == AV_RL32("yuv2") &&
AV_RL32           466 libavcodec/rawdec.c     if (avctx->codec_tag == AV_RL32("b64a") &&
AV_RL32            69 libavcodec/rawenc.c     if(avctx->codec_tag == AV_RL32("yuv2") && ret > 0 &&
AV_RL32            74 libavcodec/rawenc.c     } else if (avctx->codec_tag == AV_RL32("b64a") && ret > 0 &&
AV_RL32           154 libavcodec/rl2.c     s->clr_count  = AV_RL32(&avctx->extradata[2]);
AV_RL32           702 libavcodec/rv10.c         return AV_RL32(buf + n * 8);
AV_RL32          1568 libavcodec/rv34.c         else                   return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) :  AV_RB32(buf + n*8);
AV_RL32           516 libavcodec/sanm.c             ctx->pal[i] = 0xFFU << 24 | AV_RL32(avctx->extradata + 2 + i * 4);
AV_RL32          1818 libavcodec/sheervideo.c     if (AV_RL32(avpkt->data) != MKTAG('S','h','i','r') &&
AV_RL32          1819 libavcodec/sheervideo.c         AV_RL32(avpkt->data) != MKTAG('Z','w','a','k'))
AV_RL32          1823 libavcodec/sheervideo.c     format = AV_RL32(avpkt->data + 16);
AV_RL32           492 libavcodec/shorten.c     if (AV_RL32(s->header) == MKTAG('R','I','F','F')) {
AV_RL32           495 libavcodec/shorten.c     } else if (AV_RL32(s->header) == MKTAG('F','O','R','M')) {
AV_RL32           500 libavcodec/shorten.c                                       PRIX32, AV_RL32(s->header));
AV_RL32           324 libavcodec/smacker.c     mmap_size = AV_RL32(smk->avctx->extradata);
AV_RL32           325 libavcodec/smacker.c     mclr_size = AV_RL32(smk->avctx->extradata + 4);
AV_RL32           326 libavcodec/smacker.c     full_size = AV_RL32(smk->avctx->extradata + 8);
AV_RL32           327 libavcodec/smacker.c     type_size = AV_RL32(smk->avctx->extradata + 12);
AV_RL32           654 libavcodec/smacker.c     unp_size = AV_RL32(buf);
AV_RL32           114 libavcodec/smvjpegdec.c         s->frames_per_jpeg = AV_RL32(avctx->extradata);
AV_RL32            66 libavcodec/srtdec.c         x1 = AV_RL32(p     );
AV_RL32            67 libavcodec/srtdec.c         y1 = AV_RL32(p +  4);
AV_RL32            68 libavcodec/srtdec.c         x2 = AV_RL32(p +  8);
AV_RL32            69 libavcodec/srtdec.c         y2 = AV_RL32(p + 12);
AV_RL32          1054 libavcodec/svq3.c             uint32_t header = AV_RL32(&s->slice_buf[1]);
AV_RL32            92 libavcodec/texturedsp.c     uint32_t code   = AV_RL32(block + 4);
AV_RL32           146 libavcodec/texturedsp.c     uint32_t code   = AV_RL32(block + 12);
AV_RL32           261 libavcodec/texturedsp.c     uint32_t code   = AV_RL32(block + 12);
AV_RL32           443 libavcodec/texturedspenc.c     uint32_t first = AV_RL32(block);
AV_RL32           447 libavcodec/texturedspenc.c             if (first != AV_RL32(block + x * 4 + y * stride))
AV_RL32          1082 libavcodec/tiff.c         switch (AV_RL32(s->pattern)) {
AV_RL32          1097 libavcodec/tiff.c                    AV_RL32(s->pattern));
AV_RL32          1105 libavcodec/tiff.c         switch (AV_RL32(s->pattern)) {
AV_RL32          1120 libavcodec/tiff.c                    AV_RL32(s->pattern));
AV_RL32           253 libavcodec/truemotion2.c     uint32_t magic = AV_RL32(buf);
AV_RL32            79 libavcodec/tta.c     CRC = AV_RL32(buf + buf_size);
AV_RL32           141 libavcodec/tta.c     if (show_bits_long(&gb, 32) == AV_RL32("TTA1")) {
AV_RL32           182 libavcodec/utvideodec.c         slice_data_start = slice ? AV_RL32(src + slice * 4 - 4) : 0;
AV_RL32           183 libavcodec/utvideodec.c         slice_data_end   = AV_RL32(src + slice * 4);
AV_RL32           343 libavcodec/utvideodec.c         slice_data_start = slice ? AV_RL32(src + slice * 4 - 4) : 0;
AV_RL32           344 libavcodec/utvideodec.c         slice_data_end   = AV_RL32(src + slice * 4);
AV_RL32          1058 libavcodec/utvideodec.c         c->frame_info_size = AV_RL32(avctx->extradata + 8);
AV_RL32          1059 libavcodec/utvideodec.c         c->flags           = AV_RL32(avctx->extradata + 12);
AV_RL32            71 libavcodec/v410dec.c             val = AV_RL32(src);
AV_RL32           144 libavcodec/vble.c     version = AV_RL32(src);
AV_RL32           402 libavcodec/vmdvideo.c     s->unpack_buffer_size = AV_RL32(&vmd_header[800]);
AV_RL32          2065 libavcodec/vp8.c             uint32_t nnz4 = AV_RL32(td->non_zero_count_cache[y]);
AV_RL32          2090 libavcodec/vp8.c         uint32_t nnz4 = AV_RL32(td->non_zero_count_cache[4 + ch]);
AV_RL32          1644 libavcodec/wavpack.c     s->samples  = AV_RL32(buf + 20);
AV_RL32          1645 libavcodec/wavpack.c     frame_flags = AV_RL32(buf + 24);
AV_RL32          1655 libavcodec/wavpack.c         frame_size = AV_RL32(buf + 4) - 12;
AV_RL32           210 libavcodec/wmalosslessdec.c         channel_mask       = AV_RL32(edata_ptr +  2);
AV_RL32           363 libavcodec/wmaprodec.c         channel_mask       = AV_RL32(edata_ptr+2);
AV_RL32           394 libavcodec/wmavoice.c     flags                = AV_RL32(ctx->extradata + 18);
AV_RL32            78 libavcodec/xl.c             val  = AV_RL32(buf);
AV_RL32           300 libavcodec/ylc.c     if (AV_RL32(buf) != MKTAG('Y', 'L', 'C', '0') ||
AV_RL32           301 libavcodec/ylc.c         AV_RL32(buf + 4) != 0)
AV_RL32           304 libavcodec/ylc.c     toffset = AV_RL32(buf + 8);
AV_RL32           308 libavcodec/ylc.c     boffset = AV_RL32(buf + 12);
AV_RL32           154 libavfilter/af_anequalizer.c                     AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg));
AV_RL32           157 libavfilter/af_anequalizer.c                     AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg));
AV_RL32           200 libavfilter/avf_aphasemeter.c             AV_WL32(dst, AV_RL32(s->mpc));
AV_RL32           239 libavfilter/avf_showfreqs.c     uint32_t color = AV_RL32(out->data[0] + y * out->linesize[0] + x * 4);
AV_RL32           242 libavfilter/avf_showfreqs.c         AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg) | color);
AV_RL32           244 libavfilter/avf_showfreqs.c         AV_WL32(out->data[0] + y * out->linesize[0] + x * 4, AV_RL32(fg));
AV_RL32            88 libavformat/4xm.c     if ((AV_RL32(&p->buf[0]) != RIFF_TAG) ||
AV_RL32            89 libavformat/4xm.c         (AV_RL32(&p->buf[8]) != FOURXMV_TAG))
AV_RL32           121 libavformat/4xm.c     AV_WL32(st->codecpar->extradata, AV_RL32(buf + 16));
AV_RL32           122 libavformat/4xm.c     st->codecpar->width  = AV_RL32(buf + 36);
AV_RL32           123 libavformat/4xm.c     st->codecpar->height = AV_RL32(buf + 40);
AV_RL32           139 libavformat/4xm.c     track = AV_RL32(buf + 8);
AV_RL32           152 libavformat/4xm.c     fourxm->tracks[track].adpcm       = AV_RL32(buf + 12);
AV_RL32           153 libavformat/4xm.c     fourxm->tracks[track].channels    = AV_RL32(buf + 36);
AV_RL32           154 libavformat/4xm.c     fourxm->tracks[track].sample_rate = AV_RL32(buf + 40);
AV_RL32           155 libavformat/4xm.c     fourxm->tracks[track].bits        = AV_RL32(buf + 44);
AV_RL32           243 libavformat/4xm.c         fourcc_tag = AV_RL32(&header[i]);
AV_RL32           244 libavformat/4xm.c         size       = AV_RL32(&header[i + 4]);
AV_RL32           257 libavformat/4xm.c             fourxm->fps = av_d2q(av_int2float(AV_RL32(&header[i + 12])), 10000);
AV_RL32           307 libavformat/4xm.c         fourcc_tag = AV_RL32(&header[0]);
AV_RL32           308 libavformat/4xm.c         size       = AV_RL32(&header[4]);
AV_RL32            56 libavformat/acm.c     st->duration           = AV_RL32(st->codecpar->extradata +  4) / st->codecpar->channels;
AV_RL32            40 libavformat/act.c     if ((AV_RL32(&p->buf[0]) != RIFF_TAG) ||
AV_RL32            41 libavformat/act.c         (AV_RL32(&p->buf[8]) != WAVE_TAG) ||
AV_RL32            42 libavformat/act.c         (AV_RL32(&p->buf[16]) != 16))
AV_RL32            36 libavformat/aea.c     if (AV_RL32(p->buf)==0x800) {
AV_RL32            28 libavformat/aixdec.c     if (AV_RL32(p->buf) != MKTAG('A','I','X','F') ||
AV_RL32            43 libavformat/alp.c     if (AV_RL32(p->buf) != ALP_TAG)
AV_RL32            47 libavformat/alp.c     i = AV_RL32(p->buf + 4);
AV_RL32            53 libavformat/anm.c     if (AV_RL32(&p->buf[0])  == LPF_TAG &&
AV_RL32            54 libavformat/anm.c         AV_RL32(&p->buf[16]) == ANIM_TAG &&
AV_RL32            91 libavformat/ape.c     if (AV_RL32(p->buf) != MKTAG('M', 'A', 'C', ' '))
AV_RL32            57 libavformat/apm.c     vs12->magic                 = AV_RL32(buf + 0);
AV_RL32            58 libavformat/apm.c     vs12->file_size             = AV_RL32(buf + 4);
AV_RL32            59 libavformat/apm.c     vs12->data_size             = AV_RL32(buf + 8);
AV_RL32            60 libavformat/apm.c     vs12->unk1                  = AV_RL32(buf + 12);
AV_RL32            61 libavformat/apm.c     vs12->unk2                  = AV_RL32(buf + 16);
AV_RL32            63 libavformat/apm.c     vs12->state.has_saved       = AV_RL32(buf + 20);
AV_RL32            64 libavformat/apm.c     vs12->state.predictor_r     = AV_RL32(buf + 24);
AV_RL32            65 libavformat/apm.c     vs12->state.step_index_r    = AV_RL32(buf + 28);
AV_RL32            66 libavformat/apm.c     vs12->state.saved_r         = AV_RL32(buf + 32);
AV_RL32            67 libavformat/apm.c     vs12->state.predictor_l     = AV_RL32(buf + 36);
AV_RL32            68 libavformat/apm.c     vs12->state.step_index_l    = AV_RL32(buf + 40);
AV_RL32            69 libavformat/apm.c     vs12->state.saved_l         = AV_RL32(buf + 44);
AV_RL32            72 libavformat/apm.c         vs12->pad[i]            = AV_RL32(buf + 48 + (i * 4));
AV_RL32            80 libavformat/apm.c     if (AV_RL32(p->buf + 20) != APM_TAG_VS12)
AV_RL32            83 libavformat/apm.c     if (AV_RL32(p->buf + 96) != APM_TAG_DATA)
AV_RL32            67 libavformat/argo_asf.c     hdr->magic          = AV_RL32(buf + 0);
AV_RL32            70 libavformat/argo_asf.c     hdr->num_chunks     = AV_RL32(buf + 8);
AV_RL32            71 libavformat/argo_asf.c     hdr->chunk_offset   = AV_RL32(buf + 12);
AV_RL32            78 libavformat/argo_asf.c     hdr->num_blocks     = AV_RL32(buf + 0);
AV_RL32            79 libavformat/argo_asf.c     hdr->num_samples    = AV_RL32(buf + 4);
AV_RL32            80 libavformat/argo_asf.c     hdr->unk1           = AV_RL32(buf + 8);
AV_RL32            83 libavformat/argo_asf.c     hdr->flags          = AV_RL32(buf + 16);
AV_RL32            58 libavformat/asfcrypt.c         keys[i] = AV_RL32(keybuf + (i << 2)) | 1;
AV_RL32            30 libavformat/astdec.c     if (AV_RL32(p->buf) != MKTAG('S','T','R','M'))
AV_RL32           792 libavformat/avidec.c                             ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src + 4 * i);
AV_RL32           878 libavformat/avidec.c                     if (ast->handler == AV_RL32("Axan")) {
AV_RL32          1573 libavformat/avidec.c     if (s->nb_streams == 1 && s->streams[0]->codecpar->codec_tag == AV_RL32("MMES")) {
AV_RL32          1929 libavformat/avidec.c         if (AV_RL32(p->buf    ) == AV_RL32(avi_headers[i]    ) &&
AV_RL32          1930 libavformat/avidec.c             AV_RL32(p->buf + 8) == AV_RL32(avi_headers[i] + 4))
AV_RL32            29 libavformat/avr.c     if (AV_RL32(p->buf) != MKTAG('2', 'B', 'I', 'T'))
AV_RL32            62 libavformat/bethsoftvid.c     if (AV_RL32(p->buf) != MKTAG('V', 'I', 'D', 0))
AV_RL32            45 libavformat/bfi.c     if (AV_RL32(p->buf) == MKTAG('B', 'F', '&', 'I'))
AV_RL32            75 libavformat/bink.c             AV_RL32(b+8) > 0 &&  // num_frames
AV_RL32            76 libavformat/bink.c             AV_RL32(b+20) > 0 && AV_RL32(b+20) <= BINK_MAX_WIDTH &&
AV_RL32            77 libavformat/bink.c             AV_RL32(b+24) > 0 && AV_RL32(b+24) <= BINK_MAX_HEIGHT &&
AV_RL32            78 libavformat/bink.c             AV_RL32(b+28) > 0 && AV_RL32(b+32) > 0)  // fps num,den
AV_RL32           105 libavformat/bink.c     if (vst->codecpar->codec_tag == AV_RL32("SMUS")) {
AV_RL32           110 libavformat/bink.c         } while (!avio_feof(pb) && (vst->codecpar->codec_tag & 0xFFFFFF) != AV_RL32("BIK"));
AV_RL32           170 libavformat/bink.c     if ((signature == AV_RL32("BIK") && (revision == 'k')) ||
AV_RL32           171 libavformat/bink.c         (signature == AV_RL32("KB2") && (revision == 'i' || revision == 'j' || revision == 'k')))
AV_RL32           285 libavformat/bink.c                     AV_RL32(pkt->data) / (2 * s->streams[bink->current_track]->codecpar->channels);
AV_RL32           213 libavformat/bintext.c     if (AV_RL32(d) == MKTAG('X','B','I','N') && d[4] == 0x1A &&
AV_RL32            31 libavformat/boadec.c     if (   AV_RL32(p->buf     ) != 1
AV_RL32            32 libavformat/boadec.c         || AV_RL32(p->buf +  8) > 100000
AV_RL32            33 libavformat/boadec.c         || AV_RL32(p->buf + 12) > 8
AV_RL32            34 libavformat/boadec.c         || AV_RL32(p->buf + 16) != 2096
AV_RL32            35 libavformat/boadec.c         ||!AV_RL32(p->buf + 21)
AV_RL32            37 libavformat/boadec.c         || AV_RL32(p->buf + 48) % AV_RL32(p->buf + 21)
AV_RL32            43 libavformat/brstm.c     if (AV_RL32(p->buf) == MKTAG('R','S','T','M') &&
AV_RL32            52 libavformat/brstm.c     if ((AV_RL32(p->buf) == MKTAG('F','S','T','M') ||
AV_RL32            53 libavformat/brstm.c          AV_RL32(p->buf) == MKTAG('C','S','T','M')) &&
AV_RL32            66 libavformat/cinedec.c         AV_RL32(p->buf + 20) &&                  // ImageCount
AV_RL32            67 libavformat/cinedec.c         AV_RL32(p->buf + 24) >= HeaderSize &&    // OffImageHeader
AV_RL32            68 libavformat/cinedec.c         AV_RL32(p->buf + 28) >= HeaderSize &&    // OffSetup
AV_RL32            69 libavformat/cinedec.c         AV_RL32(p->buf + 32) >= HeaderSize)      // OffImageOffsets
AV_RL32          1793 libavformat/dashenc.c     if (AV_RL32(&buf[4]) != MKTAG('s', 'i', 'd', 'x'))
AV_RL32            29 libavformat/derf.c     if (AV_RL32(p->buf) != MKTAG('D','E','R','F'))
AV_RL32            31 libavformat/derf.c     if (AV_RL32(p->buf+4) != 1 && AV_RL32(p->buf+4) != 2)
AV_RL32            30 libavformat/dfa.c     if (p->buf_size < 4 || AV_RL32(p->buf) != MKTAG('D', 'F', 'I', 'A'))
AV_RL32            33 libavformat/dfa.c     if (AV_RL32(p->buf + 16) != 0x80)
AV_RL32           100 libavformat/dfa.c         frame_size = AV_RL32(pkt->data + pkt->size - 8);
AV_RL32           105 libavformat/dfa.c         if (AV_RL32(pkt->data + pkt->size - 12) == MKTAG('E', 'O', 'F', 'R')) {
AV_RL32            29 libavformat/diracdec.c     if (AV_RL32(p->buf) != MKTAG('B', 'B', 'C', 'D'))
AV_RL32            37 libavformat/diracdec.c     if (AV_RL32(p->buf + size) != MKTAG('B', 'B', 'C', 'D'))
AV_RL32            66 libavformat/dsicin.c     if (AV_RL32(&p->buf[0]) != 0x55AA0000)
AV_RL32            70 libavformat/dsicin.c     if (AV_RL32(&p->buf[12]) != 22050 || p->buf[16] != 16 || p->buf[17] != 0)
AV_RL32            61 libavformat/dss.c     if (   AV_RL32(p->buf) != MKTAG(0x2, 'd', 's', 's')
AV_RL32            62 libavformat/dss.c         && AV_RL32(p->buf) != MKTAG(0x3, 'd', 's', 's'))
AV_RL32           171 libavformat/dump.c     flags = AV_RL32(data);
AV_RL32           178 libavformat/dump.c         channels = AV_RL32(data);
AV_RL32           195 libavformat/dump.c         sample_rate = AV_RL32(data);
AV_RL32           203 libavformat/dump.c         width = AV_RL32(data);
AV_RL32           206 libavformat/dump.c         height = AV_RL32(data);
AV_RL32           448 libavformat/dump.c                    AV_RL32(sd.data), av_get_picture_type_char(sd.data[4]));
AV_RL32           179 libavformat/dxa.c         tag = AV_RL32(buf);
AV_RL32           465 libavformat/electronicarts.c     switch (AV_RL32(&p->buf[0])) {
AV_RL32           480 libavformat/electronicarts.c     size = AV_RL32(&p->buf[4]);
AV_RL32           641 libavformat/electronicarts.c                     pkt->duration = AV_RL32(pkt->data);
AV_RL32            30 libavformat/epafdec.c     if (((AV_RL32(p->buf) == MKTAG('f','a','p',' ') &&
AV_RL32            31 libavformat/epafdec.c           AV_RL32(p->buf + 8) == 1) ||
AV_RL32            32 libavformat/epafdec.c          (AV_RL32(p->buf) == MKTAG(' ','p','a','f') &&
AV_RL32            74 libavformat/flic.c         if(AV_RL32(&p->buf[0x10]) > 2000)
AV_RL32           103 libavformat/flic.c     speed = AV_RL32(&header[0x10]);
AV_RL32           155 libavformat/flic.c         ast->codecpar->block_align = AV_RL32(&preamble[0]);
AV_RL32           214 libavformat/flic.c         size = AV_RL32(&preamble[0]);
AV_RL32            32 libavformat/fsb.c     if (AV_RL32(p->buf + 4) != 1)
AV_RL32            29 libavformat/fwse.c     if (AV_RL32(p->buf) != MKTAG('F','W','S','E'))
AV_RL32            31 libavformat/fwse.c     if (AV_RL32(p->buf+4) != 2 && AV_RL32(p->buf+4) != 3)
AV_RL32            33 libavformat/fwse.c     if (AV_RL32(p->buf+16) != 1 && AV_RL32(p->buf+16) != 2)
AV_RL32            39 libavformat/gdv.c     if (AV_RL32(p->buf) == 0x29111994)
AV_RL32            34 libavformat/genh.c     if (AV_RL32(p->buf) != MKTAG('G','E','N','H'))
AV_RL32            36 libavformat/genh.c     if (AV_RL32(p->buf+4) <= 0 || AV_RL32(p->buf+4) > 0xFFFF) // channels
AV_RL32           314 libavformat/hashenc.c                     uint32_t data = AV_RL32(pkt->side_data[i].data + j);
AV_RL32            30 libavformat/hca.c     if (AV_RL32(p->buf) != MKTAG('H', 'C', 'A', 0))
AV_RL32            33 libavformat/hca.c     if (AV_RL32(p->buf + 8) != MKTAG('f', 'm', 't', 0))
AV_RL32            52 libavformat/hnm.c     if (AV_RL32(&p->buf[0]) == HNM4_TAG)
AV_RL32            61 libavformat/icodec.c         if (AV_RL32(p->buf + 14 + i * 16) < 40)
AV_RL32            63 libavformat/icodec.c         offset = AV_RL32(p->buf + 18 + i * 16);
AV_RL32           193 libavformat/icodec.c         if (AV_RL32(buf + 32))
AV_RL32           194 libavformat/icodec.c             image->nb_pal = AV_RL32(buf + 32);
AV_RL32           202 libavformat/icodec.c         AV_WL32(buf + 8, AV_RL32(buf + 8) / 2);
AV_RL32           137 libavformat/icoenc.c         if (AV_RL32(pkt->data + 14) != 40) { // must be BITMAPINFOHEADER
AV_RL32           146 libavformat/icoenc.c         avio_wl32(pb, AV_RL32(pkt->data + 22) * 2); // rewrite height as 2 * height
AV_RL32           117 libavformat/idcin.c     w = AV_RL32(&p->buf[0]);
AV_RL32           122 libavformat/idcin.c     h = AV_RL32(&p->buf[4]);
AV_RL32           127 libavformat/idcin.c     sample_rate = AV_RL32(&p->buf[8]);
AV_RL32           132 libavformat/idcin.c     number = AV_RL32(&p->buf[12]);
AV_RL32           137 libavformat/idcin.c     number = AV_RL32(&p->buf[16]);
AV_RL32           142 libavformat/idcin.c     if (AV_RL32(&p->buf[i]) == 1)
AV_RL32           145 libavformat/idcin.c     if (i+12 > p->buf_size || AV_RL32(&p->buf[i+8]) != w*h)
AV_RL32            65 libavformat/idroqdec.c         (AV_RL32(&p->buf[2]) != 0xFFFFFFFF))
AV_RL32           118 libavformat/idroqdec.c         chunk_size = AV_RL32(&preamble[2]);
AV_RL32           157 libavformat/idroqdec.c             chunk_size = AV_RL32(&preamble[2]) + RoQ_CHUNK_PREAMBLE_SIZE * 2 +
AV_RL32           149 libavformat/iff.c     if ( (AV_RL32(d)   == ID_FORM &&
AV_RL32           150 libavformat/iff.c          (AV_RL32(d+8) == ID_8SVX ||
AV_RL32           151 libavformat/iff.c           AV_RL32(d+8) == ID_16SV ||
AV_RL32           152 libavformat/iff.c           AV_RL32(d+8) == ID_MAUD ||
AV_RL32           153 libavformat/iff.c           AV_RL32(d+8) == ID_PBM  ||
AV_RL32           154 libavformat/iff.c           AV_RL32(d+8) == ID_ACBM ||
AV_RL32           155 libavformat/iff.c           AV_RL32(d+8) == ID_DEEP ||
AV_RL32           156 libavformat/iff.c           AV_RL32(d+8) == ID_ILBM ||
AV_RL32           157 libavformat/iff.c           AV_RL32(d+8) == ID_RGB8 ||
AV_RL32           158 libavformat/iff.c           AV_RL32(d+8) == ID_ANIM ||
AV_RL32           159 libavformat/iff.c           AV_RL32(d+8) == ID_RGBN)) ||
AV_RL32           160 libavformat/iff.c          (AV_RL32(d) == ID_FRM8 && AV_RL32(d+12) == ID_DSD))
AV_RL32           677 libavformat/img2dec.c     ihsize = AV_RL32(b+14);
AV_RL32           692 libavformat/img2dec.c         && AV_RL32(b +  8)
AV_RL32           693 libavformat/img2dec.c         && AV_RL32(b + 12))
AV_RL32           706 libavformat/img2dec.c     w = is_big ? AV_RB32(p->buf + 0x304) : AV_RL32(p->buf + 0x304);
AV_RL32           707 libavformat/img2dec.c     h = is_big ? AV_RB32(p->buf + 0x308) : AV_RL32(p->buf + 0x308);
AV_RL32           720 libavformat/img2dec.c     if (AV_RL32(b) == 20000630)
AV_RL32           880 libavformat/img2dec.c     if (AV_RL32(b) == MKTAG('8','B','P','S')) {
AV_RL32           892 libavformat/img2dec.c     if ((AV_RL32(b+6) == 0) && (AV_RL16(b+10) == 0))/* reserved must be 0 */
AV_RL32           392 libavformat/ipmovie.c             s->frame_pts_inc = ((uint64_t)AV_RL32(&scratch[0])) * AV_RL16(&scratch[4]);
AV_RL32            28 libavformat/ivfdec.c     if (AV_RL32(p->buf) == MKTAG('D','K','I','F')
AV_RL32            68 libavformat/ivfenc.c               par->codec_id == AV_CODEC_ID_VP9 ? AV_RL32("VP90") :
AV_RL32            69 libavformat/ivfenc.c               par->codec_id == AV_CODEC_ID_VP8 ? AV_RL32("VP80") : AV_RL32("AV01"));
AV_RL32            41 libavformat/kvag.c     if (AV_RL32(p->buf) != KVAG_TAG)
AV_RL32            63 libavformat/kvag.c     hdr.magic                   = AV_RL32(buf +  0);
AV_RL32            64 libavformat/kvag.c     hdr.data_size               = AV_RL32(buf +  4);
AV_RL32            65 libavformat/kvag.c     hdr.sample_rate             = AV_RL32(buf +  8);
AV_RL32            28 libavformat/lvfdec.c     if (AV_RL32(p->buf) != MKTAG('L', 'V', 'F', 'F'))
AV_RL32            31 libavformat/lvfdec.c     if (!AV_RL32(p->buf + 16) || AV_RL32(p->buf + 16) > 256)
AV_RL32            75 libavformat/lxfdec.c         sum += AV_RL32(&header[x]);
AV_RL32           161 libavformat/lxfdec.c         avio_skip(pb, (int64_t)(uint32_t)AV_RL32(p + 4) +
AV_RL32           162 libavformat/lxfdec.c                       (int64_t)(uint32_t)AV_RL32(p + 12));
AV_RL32           253 libavformat/lxfdec.c     st->duration          = AV_RL32(&header_data[32]);
AV_RL32           254 libavformat/lxfdec.c     video_params          = AV_RL32(&header_data[40]);
AV_RL32           257 libavformat/lxfdec.c     disk_params           = AV_RL32(&header_data[116]);
AV_RL32          2272 libavformat/matroskadec.c     if (ff_codec_get_id(codec_tags, AV_RL32(track->codec_priv.data))) {
AV_RL32          2284 libavformat/matroskadec.c     *fourcc = AV_RL32(track->codec_priv.data + 4);
AV_RL32          2348 libavformat/matroskadec.c                 fourcc = AV_RL32(track->video.color_space.data);
AV_RL32          2446 libavformat/matroskadec.c             fourcc              = AV_RL32(track->codec_priv.data + 16);
AV_RL32          2494 libavformat/matroskadec.c             if (codec_id == AV_CODEC_ID_NONE && AV_RL32(track->codec_priv.data+4) == AV_RL32("SMI ")) {
AV_RL32          2662 libavformat/matroskadec.c             fourcc = AV_RL32(track->codec_priv.data);
AV_RL32          3214 libavformat/matroskadec.c     samples = AV_RL32(src);
AV_RL32          3223 libavformat/matroskadec.c         uint32_t flags = AV_RL32(src);
AV_RL32          3224 libavformat/matroskadec.c         uint32_t crc   = AV_RL32(src + 4);
AV_RL32          3234 libavformat/matroskadec.c             blocksize = AV_RL32(src);
AV_RL32           782 libavformat/matroskaenc.c                 && (!par->extradata_size || ff_codec_get_id(ff_codec_movvideo_tags, AV_RL32(par->extradata + 4)) != par->codec_id)
AV_RL32          2059 libavformat/matroskaenc.c         discard_padding = av_rescale_q(AV_RL32(side_data + 4),
AV_RL32            57 libavformat/mlvdec.c     if (AV_RL32(p->buf) == MKTAG('M','L','V','I') &&
AV_RL32            58 libavformat/mlvdec.c         AV_RL32(p->buf + 4) >= 52 &&
AV_RL32            69 libavformat/mm.c     len = AV_RL32(&p->buf[2]);
AV_RL32            88 libavformat/mms.c                 mms->asf_packet_len = AV_RL32(p + sizeof(ff_asf_guid) * 2 + 64);
AV_RL32           136 libavformat/mms.c                     skip_bytes += 22 + AV_RL32(p + skip_bytes + 18);
AV_RL32           111 libavformat/mmsh.c         mmsh->chunk_seq = AV_RL32(ext_header);
AV_RL32           221 libavformat/mmst.c     mmst->header_packet_id= AV_RL32(mms->in_buffer + 40 + 7);
AV_RL32           267 libavformat/mmst.c         if(AV_RL32(mms->in_buffer + 4)==0xb00bface) {
AV_RL32           281 libavformat/mmst.c             length_remaining= AV_RL32(mms->in_buffer+8) + 4;
AV_RL32           302 libavformat/mmst.c             if (read_result >= 44 && (hr = AV_RL32(mms->in_buffer + 40))) {
AV_RL32           316 libavformat/mmst.c             mmst->incoming_packet_seq = AV_RL32(mms->in_buffer);
AV_RL32          2248 libavformat/mov.c     if (st->codecpar->codec_tag != AV_RL32("mp4s"))
AV_RL32          2456 libavformat/mov.c           (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
AV_RL32          2458 libavformat/mov.c           codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
AV_RL32          2460 libavformat/mov.c           codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
AV_RL32          2491 libavformat/mov.c         MOVAtom a = { AV_RL32("stsd") };
AV_RL32          7089 libavformat/mov.c         tag = AV_RL32(p->buf + offset + 4);
AV_RL32          7104 libavformat/mov.c                        (   AV_RL32(p->buf + offset + 8) == MKTAG('j','p','2',' ')
AV_RL32          7105 libavformat/mov.c                         || AV_RL32(p->buf + offset + 8) == MKTAG('j','p','x',' ')
AV_RL32          7141 libavformat/mov.c             if(AV_RL32(p->buf + offset     ) == MKTAG('h','d','l','r') &&
AV_RL32          7142 libavformat/mov.c                AV_RL32(p->buf + offset +  8) == MKTAG('m','h','l','r') &&
AV_RL32          7143 libavformat/mov.c                AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')){
AV_RL32          7561 libavformat/mov.c     MOVAtom atom = { AV_RL32("root") };
AV_RL32          7598 libavformat/mov.c             if (s->streams[i]->codecpar->codec_tag == AV_RL32("tmcd")) {
AV_RL32          7600 libavformat/mov.c             } else if (s->streams[i]->codecpar->codec_tag == AV_RL32("rtmd")) {
AV_RL32          7826 libavformat/mov.c     ret = mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX });
AV_RL32           767 libavformat/movenc.c     avio_wb32(pb, AV_RL32(track->par->extradata + 12)); /* InputSampleRate */
AV_RL32          1062 libavformat/movenc.c                 tag = AV_RL32("lpcm");
AV_RL32           368 libavformat/mp3enc.c                 mp3->padding = FFMAX(AV_RL32(side_data + 4) + 528 + 1, 0);
AV_RL32           370 libavformat/mp3enc.c                     mp3->delay =  FFMAX(AV_RL32(side_data) - 528 - 1, 0);
AV_RL32            84 libavformat/mpc8.c     if (AV_RL32(p->buf) != TAG_MPCK)
AV_RL32            99 libavformat/mpc8.c             if (!AV_RL32(bs)) //zero CRC is invalid
AV_RL32           917 libavformat/mpegts.c     if ((prog_reg_desc == AV_RL32("HDMV") ||
AV_RL32           918 libavformat/mpegts.c          prog_reg_desc == AV_RL32("HDPR")) &&
AV_RL32          2271 libavformat/mpegts.c              (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) );
AV_RL32          2436 libavformat/mpegts.c                 if (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) {
AV_RL32          2466 libavformat/mpegts.c             if (pes && prog_reg_desc == AV_RL32("HDMV") &&
AV_RL32          1794 libavformat/mpegtsenc.c                 trim_end = AV_RL32(side_data + 4) * 48000 / st->codecpar->sample_rate;
AV_RL32            32 libavformat/mtaf.c     if (AV_RL32(p->buf) != MKTAG('M','T','A','F') ||
AV_RL32            33 libavformat/mtaf.c         AV_RL32(p->buf + 0x40) != MKTAG('H','E','A','D'))
AV_RL32           720 libavformat/nsvdec.c         if (AV_RL32(p->buf + i) == AV_RL32("NSVs")) {
AV_RL32           924 libavformat/nutenc.c                 if (AV_RL32(data)) {
AV_RL32           926 libavformat/nutenc.c                     put_s(dyn_bc, (unsigned)AV_RL32(data));
AV_RL32           929 libavformat/nutenc.c                 if (AV_RL32(data+4)) {
AV_RL32           931 libavformat/nutenc.c                     put_s(dyn_bc, (unsigned)AV_RL32(data+4));
AV_RL32           262 libavformat/nuv.c         size      = PKTSIZE(AV_RL32(&hdr[8]));
AV_RL32           282 libavformat/nuv.c             pkt->pts          = AV_RL32(&hdr[4]);
AV_RL32           301 libavformat/nuv.c             pkt->pts          = AV_RL32(&hdr[4]);
AV_RL32           359 libavformat/nuv.c         size = PKTSIZE(AV_RL32(&hdr[8]));
AV_RL32           375 libavformat/nuv.c                     dts = AV_RL32(&hdr[4]);
AV_RL32            57 libavformat/oggparsecelt.c         version          = AV_RL32(p + 28);
AV_RL32            59 libavformat/oggparsecelt.c         sample_rate      = AV_RL32(p + 36);
AV_RL32            60 libavformat/oggparsecelt.c         nb_channels      = AV_RL32(p + 40);
AV_RL32            61 libavformat/oggparsecelt.c         overlap          = AV_RL32(p + 48);
AV_RL32            63 libavformat/oggparsecelt.c         extra_headers    = AV_RL32(p + 56);
AV_RL32           145 libavformat/oggparseogm.c     t = AV_RL32(p + 96);
AV_RL32           152 libavformat/oggparseogm.c         st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, AV_RL32(p + 68));
AV_RL32           154 libavformat/oggparseogm.c         st->codecpar->width = AV_RL32(p + 176);
AV_RL32           155 libavformat/oggparseogm.c         st->codecpar->height = AV_RL32(p + 180);
AV_RL32           163 libavformat/oggparseogm.c         st->codecpar->sample_rate = AV_RL32(p + 128);
AV_RL32           164 libavformat/oggparseogm.c         st->codecpar->bit_rate = AV_RL32(p + 132) * 8;
AV_RL32            77 libavformat/oggparseskeleton.c         target_idx = ogg_find_stream(ogg, AV_RL32(buf+12));
AV_RL32            71 libavformat/oggparsespeex.c         st->codecpar->sample_rate = AV_RL32(p + 36);
AV_RL32            76 libavformat/oggparsespeex.c         st->codecpar->channels = AV_RL32(p + 48);
AV_RL32            84 libavformat/oggparsespeex.c         spxp->packet_size  = AV_RL32(p + 56);
AV_RL32            85 libavformat/oggparsespeex.c         frames_per_packet  = AV_RL32(p + 64);
AV_RL32           380 libavformat/oggparsevorbis.c             new_len = 7 + 4 + AV_RL32(priv->packet[1] + 7) + 4 + 1;
AV_RL32            37 libavformat/pmpdec.c         AV_RL32(p->buf + 4) == 1)
AV_RL32            68 libavformat/pp_bnk.c     hdr->bank_id        = AV_RL32(buf +  0);
AV_RL32            69 libavformat/pp_bnk.c     hdr->sample_rate    = AV_RL32(buf +  4);
AV_RL32            70 libavformat/pp_bnk.c     hdr->always1        = AV_RL32(buf +  8);
AV_RL32            71 libavformat/pp_bnk.c     hdr->track_count    = AV_RL32(buf + 12);
AV_RL32            72 libavformat/pp_bnk.c     hdr->flags          = AV_RL32(buf + 16);
AV_RL32            77 libavformat/pp_bnk.c     trk->id             = AV_RL32(buf +  0);
AV_RL32            78 libavformat/pp_bnk.c     trk->size           = AV_RL32(buf +  4);
AV_RL32            79 libavformat/pp_bnk.c     trk->sample_rate    = AV_RL32(buf +  8);
AV_RL32            80 libavformat/pp_bnk.c     trk->always1_1      = AV_RL32(buf + 12);
AV_RL32            81 libavformat/pp_bnk.c     trk->always1_2      = AV_RL32(buf + 16);
AV_RL32            86 libavformat/pp_bnk.c     uint32_t sample_rate = AV_RL32(p->buf +  4);
AV_RL32            87 libavformat/pp_bnk.c     uint32_t track_count = AV_RL32(p->buf + 12);
AV_RL32            88 libavformat/pp_bnk.c     uint32_t flags       = AV_RL32(p->buf + 16);
AV_RL32            98 libavformat/pp_bnk.c     if (AV_RL32(p->buf + 28) != sample_rate)
AV_RL32            80 libavformat/psxstr.c     if ((AV_RL32(&p->buf[0]) == RIFF_TAG) &&
AV_RL32            81 libavformat/psxstr.c         (AV_RL32(&p->buf[8]) == CDXA_TAG)) {
AV_RL32           100 libavformat/psxstr.c                 int frame_size = AV_RL32(&sector[0x24]);
AV_RL32           140 libavformat/psxstr.c     if (AV_RL32(&sector[0]) == RIFF_TAG)
AV_RL32           184 libavformat/psxstr.c                 int frame_size = AV_RL32(&sector[0x24]);
AV_RL32            84 libavformat/qcp.c     if (AV_RL32(pd->buf  ) == AV_RL32("RIFF") &&
AV_RL32           369 libavformat/r3d.c     if (AV_RL32(p->buf + 4) == MKTAG('R','E','D','1'))
AV_RL32            78 libavformat/riffdec.c         par->codec_tag = AV_RL32(subformat);
AV_RL32           163 libavformat/riffdec.c         par->sample_rate   = AV_RL32(par->extradata + 12);
AV_RL32           190 libavformat/rmdec.c             ast->deint_id = AV_RL32(buf);
AV_RL32           194 libavformat/rmdec.c         st->codecpar->codec_tag  = AV_RL32(buf);
AV_RL32           337 libavformat/rmdec.c         st->codecpar->codec_tag  = AV_RL32(st->codecpar->extradata);
AV_RL32            48 libavformat/rsd.c     if (AV_RL32(p->buf +  8) > 256 || !AV_RL32(p->buf +  8))
AV_RL32            50 libavformat/rsd.c     if (AV_RL32(p->buf + 16) > 8*48000 || !AV_RL32(p->buf + 16))
AV_RL32           197 libavformat/rtmpcrypt.c     xl = AV_RL32(in);
AV_RL32           198 libavformat/rtmpcrypt.c     xr = AV_RL32(in + 4);
AV_RL32           224 libavformat/rtmppkt.c                 extra = AV_RL32(buf);
AV_RL32            69 libavformat/rtpdec_asf.c         if (AV_RL32(p) == AV_RL32(p + 4)) {
AV_RL32           139 libavformat/rtpenc_h263_rfc2190.c                     uint32_t pos = AV_RL32(&mb_info[12*mb_info_pos])/8;
AV_RL32           146 libavformat/rtpenc_h263_rfc2190.c                     uint32_t pos = AV_RL32(&mb_info[12*(mb_info_pos + 1)])/8;
AV_RL32           154 libavformat/rtpenc_h263_rfc2190.c                     uint32_t bit_pos = AV_RL32(ptr);
AV_RL32            28 libavformat/sdr2.c     if (AV_RL32(p->buf) != MKTAG('S', 'R', 'A', 1))
AV_RL32           178 libavformat/sierravmd.c     toc_offset = AV_RL32(&vmd->vmd_header[812]);
AV_RL32           206 libavformat/sierravmd.c         current_offset = AV_RL32(&raw_frame_table[6 * i + 2]);
AV_RL32           220 libavformat/sierravmd.c             size = AV_RL32(&chunk[2]);
AV_RL32            67 libavformat/siff.c     uint32_t tag = AV_RL32(p->buf + 8);
AV_RL32            69 libavformat/siff.c     if (AV_RL32(p->buf) != TAG_SIFF ||
AV_RL32            79 libavformat/smacker.c     if (   AV_RL32(p->buf) != MKTAG('S', 'M', 'K', '2')
AV_RL32            80 libavformat/smacker.c         && AV_RL32(p->buf) != MKTAG('S', 'M', 'K', '4'))
AV_RL32            83 libavformat/smacker.c     if (AV_RL32(p->buf+4) > 32768U || AV_RL32(p->buf+8) > 32768U)
AV_RL32           356 libavformat/smacker.c         smk->aud_pts[smk->curstream] += AV_RL32(pkt->data);
AV_RL32            36 libavformat/smush.c     if (((AV_RL32(p->buf)     == MKTAG('S', 'A', 'N', 'M') &&
AV_RL32            37 libavformat/smush.c           AV_RL32(p->buf + 8) == MKTAG('S', 'H', 'D', 'R')) ||
AV_RL32            38 libavformat/smush.c          (AV_RL32(p->buf)     == MKTAG('A', 'N', 'I', 'M') &&
AV_RL32            39 libavformat/smush.c           AV_RL32(p->buf + 8) == MKTAG('A', 'H', 'D', 'R')))) {
AV_RL32            38 libavformat/sol.c     uint16_t magic = AV_RL32(p->buf);
AV_RL32            42 libavformat/soxdec.c     if (AV_RL32(p->buf) == SOX_TAG || AV_RB32(p->buf) == SOX_TAG)
AV_RL32            69 libavformat/srtenc.c         x1 = AV_RL32(p     );
AV_RL32            70 libavformat/srtenc.c         y1 = AV_RL32(p +  4);
AV_RL32            71 libavformat/srtenc.c         x2 = AV_RL32(p +  8);
AV_RL32            72 libavformat/srtenc.c         y2 = AV_RL32(p + 12);
AV_RL32            52 libavformat/thp.c     if (AV_RL32(p->buf) != MKTAG('T', 'H', 'P', '\0'))
AV_RL32            56 libavformat/tmv.c     if (AV_RL32(p->buf)   == TMV_TAG &&
AV_RL32            40 libavformat/tta.c     if (AV_RL32(&p->buf[0]) == MKTAG('T', 'T', 'A', '1') &&
AV_RL32            44 libavformat/tta.c         AV_RL32(&p->buf[10]) > 0)
AV_RL32            63 libavformat/tta.c     if (avio_rl32(s->pb) != AV_RL32("TTA1"))
AV_RL32            35 libavformat/txd.c     if (AV_RL32(pd->buf  ) == TXD_FILE &&
AV_RL32            36 libavformat/txd.c        (AV_RL32(pd->buf+8) == TXD_MARKER || AV_RL32(pd->buf+8) == TXD_MARKER2))
AV_RL32           560 libavformat/udp.c         len=AV_RL32(tmp);
AV_RL32           959 libavformat/udp.c                 avail= AV_RL32(tmp);
AV_RL32           966 libavformat/udp.c                 av_fifo_drain(s->fifo, AV_RL32(tmp) - avail);
AV_RL32          3312 libavformat/utils.c         c->codec_tag == AV_RL32("mp4v") ||
AV_RL32          5741 libavformat/utils.c             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
AV_RL32          5817 libavformat/utils.c     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
AV_RL32            42 libavformat/vc1test.c     size = AV_RL32(&p->buf[4]);
AV_RL32            44 libavformat/vc1test.c         AV_RL32(&p->buf[size+16]) != 0xC)
AV_RL32           119 libavformat/vividas.c     return AV_RL32(sample) ^ AV_RL32(plaintext);
AV_RL32            35 libavformat/vpk.c     if (AV_RL32(p->buf) != MKBETAG('V','P','K',' '))
AV_RL32            37 libavformat/vqf.c     if (AV_RL32(probe_packet->buf) != MKTAG('T','W','I','N'))
AV_RL32            46 libavformat/vqf.c     if (AV_RL32(probe_packet->buf + 12) > (1<<27))
AV_RL32            81 libavformat/wc3movie.c     if ((AV_RL32(&p->buf[0]) != FORM_TAG) ||
AV_RL32            82 libavformat/wc3movie.c         (AV_RL32(&p->buf[8]) != MOVE_TAG))
AV_RL32            62 libavformat/webpenc.c         if (AV_RL32(pkt->data) == AV_RL32("RIFF"))
AV_RL32            67 libavformat/webpenc.c         if (AV_RL32(pkt->data + skip) == AV_RL32("VP8X")) {
AV_RL32            89 libavformat/webpenc.c         if (AV_RL32(w->last_pkt.data) == AV_RL32("RIFF"))
AV_RL32            94 libavformat/webpenc.c         if (AV_RL32(w->last_pkt.data + skip) == AV_RL32("VP8X")) {
AV_RL32            97 libavformat/webpenc.c             skip += AV_RL32(w->last_pkt.data + skip + 4) + 8;
AV_RL32            76 libavformat/westwood_aud.c     if (AV_RL32(&p->buf[16]) != AUD_CHUNK_SIGNATURE)
AV_RL32           143 libavformat/westwood_aud.c     if (AV_RL32(&preamble[4]) != AUD_CHUNK_SIGNATURE)
AV_RL32            43 libavformat/wtvdec.c     AV_RL32(g),AV_RL16(g+4),AV_RL16(g+6),g[8],g[9],g[10],g[11],g[12],g[13],g[14],g[15]
AV_RL32           270 libavformat/wtvdec.c         name_size   = 2 * AV_RL32(buf + 32);
AV_RL32           280 libavformat/wtvdec.c         first_sector = AV_RL32(buf + 40 + name_size);
AV_RL32           281 libavformat/wtvdec.c         depth        = AV_RL32(buf + 44 + name_size);
AV_RL32           584 libavformat/wtvdec.c     st->codecpar->bit_rate = AV_RL32(st->codecpar->extradata + 2); /* dwHeadBitrate */
AV_RL32           678 libavformat/wtvdec.c             st->codecpar->codec_id = ff_wav_codec_get_id(AV_RL32(subtype), st->codecpar->bits_per_coded_sample);
AV_RL32           708 libavformat/wtvdec.c             st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, AV_RL32(subtype));
AV_RL32            33 libavformat/wv.c     if (AV_RL32(data) != MKTAG('w', 'v', 'p', 'k'))
AV_RL32            36 libavformat/wv.c     wv->blocksize     = AV_RL32(data + 4);
AV_RL32            42 libavformat/wv.c     wv->total_samples = AV_RL32(data + 12);
AV_RL32            43 libavformat/wv.c     wv->block_idx     = AV_RL32(data + 16);
AV_RL32            44 libavformat/wv.c     wv->samples       = AV_RL32(data + 20);
AV_RL32            45 libavformat/wv.c     wv->flags         = AV_RL32(data + 24);
AV_RL32            46 libavformat/wv.c     wv->crc           = AV_RL32(data + 28);
AV_RL32            68 libavformat/wvdec.c     if (AV_RL32(&p->buf[0]) == MKTAG('w', 'v', 'p', 'k') &&
AV_RL32            69 libavformat/wvdec.c         AV_RL32(&p->buf[4]) >= 24 &&
AV_RL32            70 libavformat/wvdec.c         AV_RL32(&p->buf[4]) <= WV_BLOCK_LIMIT &&
AV_RL32            48 libavformat/xa.c     switch(AV_RL32(p->buf)) {
AV_RL32            57 libavformat/xa.c     srate           = AV_RL32(p->buf + 12);
AV_RL32           125 libavformat/xmv.c     file_version = AV_RL32(p->buf + 16);
AV_RL32           283 libavformat/xmv.c     xmv->video.data_size     = AV_RL32(data) & 0x007FFFFF;
AV_RL32           286 libavformat/xmv.c     xmv->video.frame_count   = (AV_RL32(data) >> 23) & 0xFF;
AV_RL32           358 libavformat/xmv.c         packet->data_size = AV_RL32(data) & 0x007FFFFF;
AV_RL32           523 libavformat/xmv.c         AV_WB32(data, AV_RL32(data));
AV_RL32           146 libavutil/avr32/intreadwrite.h #define AV_RL32 AV_RL32
AV_RL32           177 libavutil/avr32/intreadwrite.h     v.hl[1] = AV_RL32(p);
AV_RL32           178 libavutil/avr32/intreadwrite.h     v.hl[0] = AV_RL32((const uint32_t*)p+1);
AV_RL32           175 libavutil/intreadwrite.h #   if    defined(AV_RN32) && !defined(AV_RL32)
AV_RL32           177 libavutil/intreadwrite.h #   elif !defined(AV_RN32) &&  defined(AV_RL32)
AV_RL32           178 libavutil/intreadwrite.h #       define AV_RN32(p) AV_RL32(p)
AV_RL32           282 libavutil/intreadwrite.h #ifndef AV_RL32
AV_RL32           422 libavutil/intreadwrite.h #ifndef AV_RL32
AV_RL32            41 libavutil/lfg.c         c->state[i    ] = AV_RL32(tmp);
AV_RL32            42 libavutil/lfg.c         c->state[i + 1] = AV_RL32(tmp + 4);
AV_RL32            43 libavutil/lfg.c         c->state[i + 2] = AV_RL32(tmp + 8);
AV_RL32            44 libavutil/lfg.c         c->state[i + 3] = AV_RL32(tmp + 12);
AV_RL32            89 libavutil/md5.c                 a += (d ^ (b & (c ^ d)))  + AV_RL32(X+(       i  & 15));\
AV_RL32            91 libavutil/md5.c                 a += ((d & b) | (~d & c)) + AV_RL32(X+((1 + 5*i) & 15));\
AV_RL32            94 libavutil/md5.c                 a += (b ^ c ^ d)          + AV_RL32(X+((5 + 3*i) & 15));\
AV_RL32            96 libavutil/md5.c                 a += (c ^ (b | ~d))       + AV_RL32(X+((    7*i) & 15));\
AV_RL32            79 libavutil/pixdesc.c             else              val = flags & AV_PIX_FMT_FLAG_BE ? AV_RB32(p) : AV_RL32(p);
AV_RL32           152 libavutil/pixdesc.c                         uint32_t val = AV_RL32(p) | (s << shift);
AV_RL32           146 libavutil/ripemd.c         block[n] = AV_RL32(buffer + 4 * n);
AV_RL32           201 libavutil/ripemd.c         block[n] = AV_RL32(buffer + 4 * n);
AV_RL32           329 libavutil/ripemd.c         block[n] = AV_RL32(buffer + 4 * n);
AV_RL32           398 libavutil/ripemd.c         block[n] = AV_RL32(buffer + 4 * n);
AV_RL32            48 libavutil/tests/murmur3.c     return AV_RL32(hash_result) != 0x6384ba69;
AV_RL32           114 libavutil/tomi/intreadwrite.h #define AV_RL32 AV_RL32
AV_RL32           146 libavutil/twofish.c     return AV_RL32(s);
AV_RL32           184 libavutil/twofish.c     return AV_RL32(l);
AV_RL32           210 libavutil/twofish.c     P[0] = AV_RL32(src) ^ cs->K[0];
AV_RL32           211 libavutil/twofish.c     P[1] = AV_RL32(src + 4) ^ cs->K[1];
AV_RL32           212 libavutil/twofish.c     P[2] = AV_RL32(src + 8) ^ cs->K[2];
AV_RL32           213 libavutil/twofish.c     P[3] = AV_RL32(src + 12) ^ cs->K[3];
AV_RL32           238 libavutil/twofish.c     P[2] = AV_RL32(src) ^ cs->K[4];
AV_RL32           239 libavutil/twofish.c     P[3] = AV_RL32(src + 4) ^ cs->K[5];
AV_RL32           240 libavutil/twofish.c     P[0] = AV_RL32(src + 8) ^ cs->K[6];
AV_RL32           241 libavutil/twofish.c     P[1] = AV_RL32(src + 12) ^ cs->K[7];
AV_RL32           257 libavutil/twofish.c         P[0] ^= AV_RL32(iv);
AV_RL32           258 libavutil/twofish.c         P[1] ^= AV_RL32(iv + 4);
AV_RL32           259 libavutil/twofish.c         P[2] ^= AV_RL32(iv + 8);
AV_RL32           260 libavutil/twofish.c         P[3] ^= AV_RL32(iv + 12);
AV_RL32           291 libavutil/twofish.c         Key[i] = AV_RL32(keypad + 4 * i);
AV_RL32            55 libavutil/xtea.c         ctx->key[i] = AV_RL32(key + (i << 2));
AV_RL32           184 libavutil/xtea.c     v0 = AV_RL32(src);
AV_RL32           185 libavutil/xtea.c     v1 = AV_RL32(src + 4);
AV_RL32           196 libavutil/xtea.c             v0 ^= AV_RL32(iv);
AV_RL32           197 libavutil/xtea.c             v1 ^= AV_RL32(iv + 4);
AV_RL32           963 libswscale/input.c #define rdpx(src) (is_be ? av_int2float(AV_RB32(src)): av_int2float(AV_RL32(src)))