Unified · Split
| @@ -62,9 +62,9 @@ static int aea_read_header(AVFormatContext *s, · 61 unmodified lines | ||
| 62 | 62 | return AVERROR(ENOMEM); |
| 63 | 63 | |
| 64 | 64 | /* Parse the amount of channels and skip to pos 2048(0x800) */ |
| 65 | − url_fskip(s->pb, 264); | |
| 65 | + avio_seek(s->pb, 264, SEEK_CUR); | |
| 66 | 66 | st->codec->channels = avio_r8(s->pb); |
| 67 | − url_fskip(s->pb, 1783); | |
| 67 | + avio_seek(s->pb, 1783, SEEK_CUR); | |
| 68 | 68 | |
| 69 | 69 | |
| 70 | 70 | st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
| @@ -70,7 +70,7 @@ static void get_meta(AVFormatContext *s, const char *key, int size) · 69 unmodified lines | ||
| 70 | 70 | int res; |
| 71 | 71 | |
| 72 | 72 | if (!str) { |
| 73 | − url_fskip(s->pb, size); | |
| 73 | + avio_seek(s->pb, size, SEEK_CUR); | |
| 74 | 74 | return; |
| 75 | 75 | } |
| 76 | 76 | |
| @@ -242,7 +242,7 @@ static int aiff_read_header(AVFormatContext *s, · 165 unmodified lines | ||
| 242 | 242 | av_log(s, AV_LOG_ERROR, "file is not seekable\n"); |
| 243 | 243 | return -1; |
| 244 | 244 | } |
| 245 | − url_fskip(pb, size - 8); | |
| 245 | + avio_seek(pb, size - 8, SEEK_CUR); | |
| 246 | 246 | break; |
| 247 | 247 | case MKTAG('w', 'a', 'v', 'e'): |
| 248 | 248 | if ((uint64_t)size > (1<<30)) |
| @@ -256,7 +256,7 @@ static int aiff_read_header(AVFormatContext *s, · 7 unmodified lines | ||
| 256 | 256 | default: /* Jump */ |
| 257 | 257 | if (size & 1) /* Always even aligned */ |
| 258 | 258 | size++; |
| 259 | − url_fskip (pb, size); | |
| 259 | + avio_seek(pb, size, SEEK_CUR); | |
| 260 | 260 | } |
| 261 | 261 | } |
| 262 | 262 | |
| @@ -83,7 +83,7 @@ static int read_header(AVFormatContext *s, · 82 unmodified lines | ||
| 83 | 83 | AVStream *st; |
| 84 | 84 | int i, ret; |
| 85 | 85 | |
| 86 | − url_fskip(pb, 4); /* magic number */ | |
| 86 | + avio_seek(pb, 4, SEEK_CUR); /* magic number */ | |
| 87 | 87 | if (avio_rl16(pb) != MAX_PAGES) { |
| 88 | 88 | av_log_ask_for_sample(s, "max_pages != " AV_STRINGIFY(MAX_PAGES) "\n"); |
| 89 | 89 | return AVERROR_INVALIDDATA; |
| @@ -91,7 +91,7 @@ static int read_header(AVFormatContext *s, · 1 unmodified line | ||
| 91 | 91 | |
| 92 | 92 | anm->nb_pages = avio_rl16(pb); |
| 93 | 93 | anm->nb_records = avio_rl32(pb); |
| 94 | − url_fskip(pb, 2); /* max records per page */ | |
| 94 | + avio_seek(pb, 2, SEEK_CUR); /* max records per page */ | |
| 95 | 95 | anm->page_table_offset = avio_rl16(pb); |
| 96 | 96 | if (avio_rl32(pb) != ANIM_TAG) |
| 97 | 97 | return AVERROR_INVALIDDATA; |
| @@ -107,13 +107,13 @@ static int read_header(AVFormatContext *s, · 9 unmodified lines | ||
| 107 | 107 | st->codec->height = avio_rl16(pb); |
| 108 | 108 | if (avio_r8(pb) != 0) |
| 109 | 109 | goto invalid; |
| 110 | − url_fskip(pb, 1); /* frame rate multiplier info */ | |
| 110 | + avio_seek(pb, 1, SEEK_CUR); /* frame rate multiplier info */ | |
| 111 | 111 | |
| 112 | 112 | /* ignore last delta record (used for looping) */ |
| 113 | 113 | if (avio_r8(pb)) /* has_last_delta */ |
| 114 | 114 | anm->nb_records = FFMAX(anm->nb_records - 1, 0); |
| 115 | 115 | |
| 116 | − url_fskip(pb, 1); /* last_delta_valid */ | |
| 116 | + avio_seek(pb, 1, SEEK_CUR); /* last_delta_valid */ | |
| 117 | 117 | |
| 118 | 118 | if (avio_r8(pb) != 0) |
| 119 | 119 | goto invalid; |
| @@ -121,15 +121,15 @@ static int read_header(AVFormatContext *s, · 1 unmodified line | ||
| 121 | 121 | if (avio_r8(pb) != 1) |
| 122 | 122 | goto invalid; |
| 123 | 123 | |
| 124 | − url_fskip(pb, 1); /* other recs per frame */ | |
| 124 | + avio_seek(pb, 1, SEEK_CUR); /* other recs per frame */ | |
| 125 | 125 | |
| 126 | 126 | if (avio_r8(pb) != 1) |
| 127 | 127 | goto invalid; |
| 128 | 128 | |
| 129 | − url_fskip(pb, 32); /* record_types */ | |
| 129 | + avio_seek(pb, 32, SEEK_CUR); /* record_types */ | |
| 130 | 130 | st->nb_frames = avio_rl32(pb); |
| 131 | 131 | av_set_pts_info(st, 64, 1, avio_rl16(pb)); |
| 132 | − url_fskip(pb, 58); | |
| 132 | + avio_seek(pb, 58, SEEK_CUR); | |
| 133 | 133 | |
| 134 | 134 | /* color cycling and palette data */ |
| 135 | 135 | st->codec->extradata_size = 16*8 + 4*256; |
| @@ -193,7 +193,7 @@ repeat: · 57 unmodified lines | ||
| 193 | 193 | /* parse page header */ |
| 194 | 194 | if (anm->record < 0) { |
| 195 | 195 | avio_seek(pb, anm->page_table_offset + MAX_PAGES*6 + (anm->page<<16), SEEK_SET); |
| 196 | − url_fskip(pb, 8 + 2*p->nb_records); | |
| 196 | + avio_seek(pb, 8 + 2*p->nb_records, SEEK_CUR); | |
| 197 | 197 | anm->record = 0; |
| 198 | 198 | } |
| 199 | 199 | |
| @@ -239,7 +239,7 @@ static int ape_read_header(AVFormatContext * s, AVFormatParameters * ap) · 238 unmodified lines | ||
| 239 | 239 | |
| 240 | 240 | /* Skip any stored wav header */ |
| 241 | 241 | if (!(ape->formatflags & MAC_FORMAT_FLAG_CREATE_WAV_HEADER)) |
| 242 | − url_fskip(pb, ape->wavheaderlength); | |
| 242 | + avio_seek(pb, ape->wavheaderlength, SEEK_CUR); | |
| 243 | 243 | } |
| 244 | 244 | |
| 245 | 245 | if(ape->totalframes > UINT_MAX / sizeof(APEFrame)){ |
| @@ -350,7 +350,7 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size) · 349 unmodified lines | ||
| 350 | 350 | avio_rl16(pb); /* panes */ |
| 351 | 351 | st->codec->bits_per_coded_sample = avio_rl16(pb); /* depth */ |
| 352 | 352 | tag1 = avio_rl32(pb); |
| 353 | − url_fskip(pb, 20); | |
| 353 | + avio_seek(pb, 20, SEEK_CUR); | |
| 354 | 354 | // av_log(s, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX); |
| 355 | 355 | if (sizeX > 40) { |
| 356 | 356 | st->codec->extradata_size = sizeX - 40; |
| @@ -388,7 +388,7 @@ static int asf_read_stream_properties(AVFormatContext *s, int64_t size) · 31 unmodified lines | ||
| 388 | 388 | st->need_parsing = AVSTREAM_PARSE_FULL_ONCE; |
| 389 | 389 | } |
| 390 | 390 | pos2 = url_ftell(pb); |
| 391 | − url_fskip(pb, size - (pos2 - pos1 + 24)); | |
| 391 | + avio_seek(pb, size - (pos2 - pos1 + 24), SEEK_CUR); | |
| 392 | 392 | |
| 393 | 393 | return 0; |
| 394 | 394 | } |
| @@ -455,7 +455,7 @@ static int asf_read_content_desc(AVFormatContext *s, int64_t size) · 60 unmodified lines | ||
| 455 | 455 | get_tag(s, "author" , 0, len2); |
| 456 | 456 | get_tag(s, "copyright", 0, len3); |
| 457 | 457 | get_tag(s, "comment" , 0, len4); |
| 458 | − url_fskip(pb, len5); | |
| 458 | + avio_seek(pb, len5, SEEK_CUR); | |
| 459 | 459 | |
| 460 | 460 | return 0; |
| 461 | 461 | } |
| @@ -475,7 +475,7 @@ static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size) · 13 unmodified lines | ||
| 475 | 475 | if (name_len%2) // must be even, broken lavf versions wrote len-1 |
| 476 | 476 | name_len += 1; |
| 477 | 477 | if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len) |
| 478 | − url_fskip(pb, name_len - ret); | |
| 478 | + avio_seek(pb, name_len - ret, SEEK_CUR); | |
| 479 | 479 | value_type = avio_rl16(pb); |
| 480 | 480 | value_len = avio_rl16(pb); |
| 481 | 481 | if (!value_type && value_len%2) |
| @@ -505,7 +505,7 @@ static int asf_read_language_list(AVFormatContext *s, int64_t size) · 23 unmodified lines | ||
| 505 | 505 | char lang[6]; |
| 506 | 506 | unsigned int lang_len = avio_r8(pb); |
| 507 | 507 | if ((ret = avio_get_str16le(pb, lang_len, lang, sizeof(lang))) < lang_len) |
| 508 | − url_fskip(pb, lang_len - ret); | |
| 508 | + avio_seek(pb, lang_len - ret, SEEK_CUR); | |
| 509 | 509 | if (j < 128) |
| 510 | 510 | av_strlcpy(asf->stream_languages[j], lang, sizeof(*asf->stream_languages)); |
| 511 | 511 | } |
| @@ -531,10 +531,10 @@ static int asf_read_metadata(AVFormatContext *s, int64_t size) · 19 unmodified lines | ||
| 531 | 531 | value_len= avio_rl32(pb); |
| 532 | 532 | |
| 533 | 533 | if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len) |
| 534 | − url_fskip(pb, name_len - ret); | |
| 534 | + avio_seek(pb, name_len - ret, SEEK_CUR); | |
| 535 | 535 | //av_log(s, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name); |
| 536 | 536 | value_num= avio_rl16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere |
| 537 | − url_fskip(pb, value_len - 2); | |
| 537 | + avio_seek(pb, value_len - 2, SEEK_CUR); | |
| 538 | 538 | |
| 539 | 539 | if(stream_num<128){ |
| 540 | 540 | if (!strcmp(name, "AspectRatioX")) asf->dar[stream_num].num= value_num; |
| @@ -571,7 +571,7 @@ static int asf_read_marker(AVFormatContext *s, int64_t size) · 30 unmodified lines | ||
| 571 | 571 | avio_rl32(pb); // flags |
| 572 | 572 | name_len = avio_rl32(pb); // name length |
| 573 | 573 | if ((ret = avio_get_str16le(pb, name_len * 2, name, sizeof(name))) < name_len) |
| 574 | − url_fskip(pb, name_len - ret); | |
| 574 | + avio_seek(pb, name_len - ret, SEEK_CUR); | |
| 575 | 575 | ff_new_chapter(s, i, (AVRational){1, 10000000}, pres_time, AV_NOPTS_VALUE, name ); |
| 576 | 576 | } |
| 577 | 577 | |
| @@ -826,16 +826,16 @@ static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){ · 248 unmodified lines | ||
| 826 | 826 | // for(i=0; i<asf->packet_replic_size-8; i++) |
| 827 | 827 | // av_log(s, AV_LOG_DEBUG, "%02X ",avio_r8(pb)); |
| 828 | 828 | // av_log(s, AV_LOG_DEBUG, "\n"); |
| 829 | − url_fskip(pb, 10); | |
| 829 | + avio_seek(pb, 10, SEEK_CUR); | |
| 830 | 830 | ts0= avio_rl64(pb); |
| 831 | 831 | ts1= avio_rl64(pb); |
| 832 | − url_fskip(pb, 12); | |
| 832 | + avio_seek(pb, 12, SEEK_CUR); | |
| 833 | 833 | avio_rl32(pb); |
| 834 | − url_fskip(pb, asf->packet_replic_size - 8 - 38 - 4); | |
| 834 | + avio_seek(pb, asf->packet_replic_size - 8 - 38 - 4, SEEK_CUR); | |
| 835 | 835 | if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000; |
| 836 | 836 | else asf->packet_frag_timestamp= AV_NOPTS_VALUE; |
| 837 | 837 | }else |
| 838 | − url_fskip(pb, asf->packet_replic_size - 8); | |
| 838 | + avio_seek(pb, asf->packet_replic_size - 8, SEEK_CUR); | |
| 839 | 839 | rsize += asf->packet_replic_size; // FIXME - check validity |
| 840 | 840 | } else if (asf->packet_replic_size==1){ |
| 841 | 841 | // multipacket - frag_offset is beginning timestamp |
| @@ -895,7 +895,7 @@ static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pk · 53 unmodified lines | ||
| 895 | 895 | //printf("PacketLeftSize:%d Pad:%d Pos:%"PRId64"\n", asf->packet_size_left, asf->packet_padsize, url_ftell(pb)); |
| 896 | 896 | assert(ret>=0); |
| 897 | 897 | /* fail safe */ |
| 898 | − url_fskip(pb, ret); | |
| 898 | + avio_seek(pb, ret, SEEK_CUR); | |
| 899 | 899 | |
| 900 | 900 | asf->packet_pos= url_ftell(pb); |
| 901 | 901 | if (asf->data_object_size != (uint64_t)-1 && |
| @@ -914,7 +914,7 @@ static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pk · 12 unmodified lines | ||
| 914 | 914 | ) { |
| 915 | 915 | asf->packet_time_start = 0; |
| 916 | 916 | /* unhandled packet (should not happen) */ |
| 917 | − url_fskip(pb, asf->packet_frag_size); | |
| 917 | + avio_seek(pb, asf->packet_frag_size, SEEK_CUR); | |
| 918 | 918 | asf->packet_size_left -= asf->packet_frag_size; |
| 919 | 919 | if(asf->stream_index < 0) |
| 920 | 920 | av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size); |
| @@ -934,7 +934,7 @@ static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pk · 13 unmodified lines | ||
| 934 | 934 | if (asf->packet_multi_size < asf->packet_obj_size) |
| 935 | 935 | { |
| 936 | 936 | asf->packet_time_start = 0; |
| 937 | − url_fskip(pb, asf->packet_multi_size); | |
| 937 | + avio_seek(pb, asf->packet_multi_size, SEEK_CUR); | |
| 938 | 938 | asf->packet_size_left -= asf->packet_multi_size; |
| 939 | 939 | continue; |
| 940 | 940 | } |
| @@ -321,12 +321,12 @@ static void avi_read_nikon(AVFormatContext *s, uint64_t end) · 320 unmodified lines | ||
| 321 | 321 | } |
| 322 | 322 | if (name) |
| 323 | 323 | av_metadata_set2(&s->metadata, name, buffer, 0); |
| 324 | − url_fskip(s->pb, size); | |
| 324 | + avio_seek(s->pb, size, SEEK_CUR); | |
| 325 | 325 | } |
| 326 | 326 | break; |
| 327 | 327 | } |
| 328 | 328 | default: |
| 329 | − url_fskip(s->pb, size); | |
| 329 | + avio_seek(s->pb, size, SEEK_CUR); | |
| 330 | 330 | break; |
| 331 | 331 | } |
| 332 | 332 | } |
| @@ -392,13 +392,13 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 59 unmodified lines | ||
| 392 | 392 | unsigned char date[64] = {0}; |
| 393 | 393 | size += (size & 1); |
| 394 | 394 | size -= avio_read(pb, date, FFMIN(size, sizeof(date)-1)); |
| 395 | − url_fskip(pb, size); | |
| 395 | + avio_seek(pb, size, SEEK_CUR); | |
| 396 | 396 | avi_metadata_creation_time(&s->metadata, date); |
| 397 | 397 | break; |
| 398 | 398 | } |
| 399 | 399 | case MKTAG('d', 'm', 'l', 'h'): |
| 400 | 400 | avi->is_odml = 1; |
| 401 | − url_fskip(pb, size + (size & 1)); | |
| 401 | + avio_seek(pb, size + (size & 1), SEEK_CUR); | |
| 402 | 402 | break; |
| 403 | 403 | case MKTAG('a', 'm', 'v', 'h'): |
| 404 | 404 | amv_file_format=1; |
| @@ -410,13 +410,13 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 5 unmodified lines | ||
| 410 | 410 | avio_rl32(pb); |
| 411 | 411 | avi->non_interleaved |= avio_rl32(pb) & AVIF_MUSTUSEINDEX; |
| 412 | 412 | |
| 413 | − url_fskip(pb, 2 * 4); | |
| 413 | + avio_seek(pb, 2 * 4, SEEK_CUR); | |
| 414 | 414 | avio_rl32(pb); |
| 415 | 415 | avio_rl32(pb); |
| 416 | 416 | avih_width=avio_rl32(pb); |
| 417 | 417 | avih_height=avio_rl32(pb); |
| 418 | 418 | |
| 419 | − url_fskip(pb, size - 10 * 4); | |
| 419 | + avio_seek(pb, size - 10 * 4, SEEK_CUR); | |
| 420 | 420 | break; |
| 421 | 421 | case MKTAG('s', 't', 'r', 'h'): |
| 422 | 422 | /* stream header */ |
| @@ -425,7 +425,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 2 unmodified lines | ||
| 425 | 425 | handler = avio_rl32(pb); /* codec tag */ |
| 426 | 426 | |
| 427 | 427 | if(tag1 == MKTAG('p', 'a', 'd', 's')){ |
| 428 | − url_fskip(pb, size - 8); | |
| 428 | + avio_seek(pb, size - 8, SEEK_CUR); | |
| 429 | 429 | break; |
| 430 | 430 | }else{ |
| 431 | 431 | stream_index++; |
| @@ -469,10 +469,10 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 37 unmodified lines | ||
| 469 | 469 | goto fail; |
| 470 | 470 | } |
| 471 | 471 | s->streams[0]->priv_data = ast; |
| 472 | − url_fskip(pb, 3 * 4); | |
| 472 | + avio_seek(pb, 3 * 4, SEEK_CUR); | |
| 473 | 473 | ast->scale = avio_rl32(pb); |
| 474 | 474 | ast->rate = avio_rl32(pb); |
| 475 | − url_fskip(pb, 4); /* start time */ | |
| 475 | + avio_seek(pb, 4, SEEK_CUR); /* start time */ | |
| 476 | 476 | |
| 477 | 477 | dv_dur = avio_rl32(pb); |
| 478 | 478 | if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) { |
| @@ -485,7 +485,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 6 unmodified lines | ||
| 485 | 485 | */ |
| 486 | 486 | |
| 487 | 487 | stream_index = s->nb_streams - 1; |
| 488 | − url_fskip(pb, size - 9*4); | |
| 488 | + avio_seek(pb, size - 9*4, SEEK_CUR); | |
| 489 | 489 | break; |
| 490 | 490 | } |
| 491 | 491 | |
| @@ -542,12 +542,12 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 50 unmodified lines | ||
| 542 | 542 | if(ast->sample_size == 0) |
| 543 | 543 | st->duration = st->nb_frames; |
| 544 | 544 | ast->frame_offset= ast->cum_len; |
| 545 | − url_fskip(pb, size - 12 * 4); | |
| 545 | + avio_seek(pb, size - 12 * 4, SEEK_CUR); | |
| 546 | 546 | break; |
| 547 | 547 | case MKTAG('s', 't', 'r', 'f'): |
| 548 | 548 | /* stream header */ |
| 549 | 549 | if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) { |
| 550 | − url_fskip(pb, size); | |
| 550 | + avio_seek(pb, size, SEEK_CUR); | |
| 551 | 551 | } else { |
| 552 | 552 | uint64_t cur_pos = url_ftell(pb); |
| 553 | 553 | if (cur_pos < list_end) |
| @@ -560,7 +560,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 6 unmodified lines | ||
| 560 | 560 | st->codec->height=avih_height; |
| 561 | 561 | st->codec->codec_type = AVMEDIA_TYPE_VIDEO; |
| 562 | 562 | st->codec->codec_id = CODEC_ID_AMV; |
| 563 | − url_fskip(pb, size); | |
| 563 | + avio_seek(pb, size, SEEK_CUR); | |
| 564 | 564 | break; |
| 565 | 565 | } |
| 566 | 566 | tag1 = ff_get_bmp_header(pb, st); |
| @@ -620,7 +620,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 53 unmodified lines | ||
| 620 | 620 | } |
| 621 | 621 | st->codec->height= FFABS(st->codec->height); |
| 622 | 622 | |
| 623 | −// url_fskip(pb, size - 5 * 4); | |
| 623 | +// avio_seek(pb, size - 5 * 4, SEEK_CUR); | |
| 624 | 624 | break; |
| 625 | 625 | case AVMEDIA_TYPE_AUDIO: |
| 626 | 626 | ff_get_wav_header(pb, st->codec, size); |
| @@ -630,7 +630,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 3 unmodified lines | ||
| 630 | 630 | ast->sample_size= st->codec->block_align; |
| 631 | 631 | } |
| 632 | 632 | if (size&1) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */ |
| 633 | − url_fskip(pb, 1); | |
| 633 | + avio_seek(pb, 1, SEEK_CUR); | |
| 634 | 634 | /* Force parsing as several audio frames can be in |
| 635 | 635 | * one packet and timestamps refer to packet start. */ |
| 636 | 636 | st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS; |
| @@ -658,7 +658,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 21 unmodified lines | ||
| 658 | 658 | st->codec->codec_type = AVMEDIA_TYPE_DATA; |
| 659 | 659 | st->codec->codec_id= CODEC_ID_NONE; |
| 660 | 660 | st->codec->codec_tag= 0; |
| 661 | − url_fskip(pb, size); | |
| 661 | + avio_seek(pb, size, SEEK_CUR); | |
| 662 | 662 | break; |
| 663 | 663 | } |
| 664 | 664 | } |
| @@ -710,7 +710,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) · 45 unmodified lines | ||
| 710 | 710 | } |
| 711 | 711 | /* skip tag */ |
| 712 | 712 | size += (size & 1); |
| 713 | − url_fskip(pb, size); | |
| 713 | + avio_seek(pb, size, SEEK_CUR); | |
| 714 | 714 | break; |
| 715 | 715 | } |
| 716 | 716 | } |
| @@ -762,7 +762,7 @@ static int read_gab2_sub(AVStream *st, AVPacket *pkt) { · 45 unmodified lines | ||
| 762 | 762 | goto error; |
| 763 | 763 | |
| 764 | 764 | ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc)); |
| 765 | − url_fskip(pb, desc_len - ret); | |
| 765 | + avio_seek(pb, desc_len - ret, SEEK_CUR); | |
| 766 | 766 | if (*desc) |
| 767 | 767 | av_metadata_set2(&st->metadata, "title", desc, 0); |
| 768 | 768 | |
| @@ -1008,14 +1008,14 @@ resync: · 239 unmodified lines | ||
| 1008 | 1008 | //parse JUNK |
| 1009 | 1009 | ||(d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') |
| 1010 | 1010 | ||(d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')){ |
| 1011 | − url_fskip(pb, size); | |
| 1011 | + avio_seek(pb, size, SEEK_CUR); | |
| 1012 | 1012 | //av_log(s, AV_LOG_DEBUG, "SKIP\n"); |
| 1013 | 1013 | goto resync; |
| 1014 | 1014 | } |
| 1015 | 1015 | |
| 1016 | 1016 | //parse stray LIST |
| 1017 | 1017 | if(d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T'){ |
| 1018 | − url_fskip(pb, 4); | |
| 1018 | + avio_seek(pb, 4, SEEK_CUR); | |
| 1019 | 1019 | goto resync; |
| 1020 | 1020 | } |
| 1021 | 1021 | |
| @@ -1026,7 +1026,7 @@ resync: · 4 unmodified lines | ||
| 1026 | 1026 | |
| 1027 | 1027 | //detect ##ix chunk and skip |
| 1028 | 1028 | if(d[2] == 'i' && d[3] == 'x' && n < s->nb_streams){ |
| 1029 | − url_fskip(pb, size); | |
| 1029 | + avio_seek(pb, size, SEEK_CUR); | |
| 1030 | 1030 | goto resync; |
| 1031 | 1031 | } |
| 1032 | 1032 | |
| @@ -1060,7 +1060,7 @@ resync: · 27 unmodified lines | ||
| 1060 | 1060 | /*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & AV_PKT_FLAG_KEY))*/ //FIXME needs a little reordering |
| 1061 | 1061 | || st->discard >= AVDISCARD_ALL){ |
| 1062 | 1062 | ast->frame_offset += get_duration(ast, size); |
| 1063 | − url_fskip(pb, size); | |
| 1063 | + avio_seek(pb, size, SEEK_CUR); | |
| 1064 | 1064 | goto resync; |
| 1065 | 1065 | } |
| 1066 | 1066 | |
| @@ -444,9 +444,9 @@ static int avi_write_ix(AVFormatContext *s) · 443 unmodified lines | ||
| 444 | 444 | /* Updating one entry in the AVI OpenDML master index */ |
| 445 | 445 | avio_seek(pb, avist->indexes.indx_start - 8, SEEK_SET); |
| 446 | 446 | ffio_wfourcc(pb, "indx"); /* enabling this entry */ |
| 447 | − url_fskip(pb, 8); | |
| 447 | + avio_seek(pb, 8, SEEK_CUR); | |
| 448 | 448 | avio_wl32(pb, avi->riff_id); /* nEntriesInUse */ |
| 449 | − url_fskip(pb, 16*avi->riff_id); | |
| 449 | + avio_seek(pb, 16*avi->riff_id, SEEK_CUR); | |
| 450 | 450 | avio_wl64(pb, ix); /* qwOffset */ |
| 451 | 451 | avio_wl32(pb, pos - ix); /* dwSize */ |
| 452 | 452 | avio_wl32(pb, avist->indexes.entry); /* dwDuration */ |
| @@ -603,7 +603,7 @@ static int avi_write_trailer(AVFormatContext *s) · 150 unmodified lines | ||
| 603 | 603 | file_size = url_ftell(pb); |
| 604 | 604 | avio_seek(pb, avi->odml_list - 8, SEEK_SET); |
| 605 | 605 | ffio_wfourcc(pb, "LIST"); /* Making this AVI OpenDML one */ |
| 606 | − url_fskip(pb, 16); | |
| 606 | + avio_seek(pb, 16, SEEK_CUR); | |
| 607 | 607 | |
| 608 | 608 | for (n=nb_frames=0;n<s->nb_streams;n++) { |
| 609 | 609 | AVCodecContext *stream = s->streams[n]->codec; |
| @@ -61,7 +61,7 @@ static int avs_read_header(AVFormatContext * s, AVFormatParameters * ap) · 60 unmodified lines | ||
| 61 | 61 | |
| 62 | 62 | s->ctx_flags |= AVFMTCTX_NOHEADER; |
| 63 | 63 | |
| 64 | − url_fskip(s->pb, 4); | |
| 64 | + avio_seek(s->pb, 4, SEEK_CUR); | |
| 65 | 65 | avs->width = avio_rl16(s->pb); |
| 66 | 66 | avs->height = avio_rl16(s->pb); |
| 67 | 67 | avs->bits_per_sample = avio_rl16(s->pb); |
| @@ -204,7 +204,7 @@ static int avs_read_packet(AVFormatContext * s, AVPacket * pkt) · 136 unmodified lines | ||
| 204 | 204 | break; |
| 205 | 205 | |
| 206 | 206 | default: |
| 207 | − url_fskip(s->pb, size - 4); | |
| 207 | + avio_seek(s->pb, size - 4, SEEK_CUR); | |
| 208 | 208 | } |
| 209 | 209 | } |
| 210 | 210 | } |
| @@ -65,19 +65,19 @@ static int bfi_read_header(AVFormatContext * s, AVFormatParameters * ap) · 64 unmodified lines | ||
| 65 | 65 | return AVERROR(ENOMEM); |
| 66 | 66 | |
| 67 | 67 | /* Set the total number of frames. */ |
| 68 | − url_fskip(pb, 8); | |
| 68 | + avio_seek(pb, 8, SEEK_CUR); | |
| 69 | 69 | chunk_header = avio_rl32(pb); |
| 70 | 70 | bfi->nframes = avio_rl32(pb); |
| 71 | 71 | avio_rl32(pb); |
| 72 | 72 | avio_rl32(pb); |
| 73 | 73 | avio_rl32(pb); |
| 74 | 74 | fps = avio_rl32(pb); |
| 75 | − url_fskip(pb, 12); | |
| 75 | + avio_seek(pb, 12, SEEK_CUR); | |
| 76 | 76 | vstream->codec->width = avio_rl32(pb); |
| 77 | 77 | vstream->codec->height = avio_rl32(pb); |
| 78 | 78 | |
| 79 | 79 | /*Load the palette to extradata */ |
| 80 | − url_fskip(pb, 8); | |
| 80 | + avio_seek(pb, 8, SEEK_CUR); | |
| 81 | 81 | vstream->codec->extradata = av_malloc(768); |
| 82 | 82 | vstream->codec->extradata_size = 768; |
| 83 | 83 | avio_read(pb, vstream->codec->extradata, |
| @@ -98,7 +98,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap) · 97 unmodified lines | ||
| 98 | 98 | return AVERROR(EIO); |
| 99 | 99 | } |
| 100 | 100 | |
| 101 | − url_fskip(pb, 4); | |
| 101 | + avio_seek(pb, 4, SEEK_CUR); | |
| 102 | 102 | |
| 103 | 103 | vst->codec->width = avio_rl32(pb); |
| 104 | 104 | vst->codec->height = avio_rl32(pb); |
| @@ -127,7 +127,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap) · 22 unmodified lines | ||
| 127 | 127 | } |
| 128 | 128 | |
| 129 | 129 | if (bink->num_audio_tracks) { |
| 130 | − url_fskip(pb, 4 * bink->num_audio_tracks); | |
| 130 | + avio_seek(pb, 4 * bink->num_audio_tracks, SEEK_CUR); | |
| 131 | 131 | |
| 132 | 132 | for (i = 0; i < bink->num_audio_tracks; i++) { |
| 133 | 133 | ast = av_new_stream(s, 1); |
| @@ -169,7 +169,7 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap) · 35 unmodified lines | ||
| 169 | 169 | keyframe ? AVINDEX_KEYFRAME : 0); |
| 170 | 170 | } |
| 171 | 171 | |
| 172 | − url_fskip(pb, 4); | |
| 172 | + avio_seek(pb, 4, SEEK_CUR); | |
| 173 | 173 | |
| 174 | 174 | bink->current_track = -1; |
| 175 | 175 | return 0; |
| @@ -122,7 +122,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt) · 121 unmodified lines | ||
| 122 | 122 | return AVERROR(ENOMEM); |
| 123 | 123 | c93->audio->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
| 124 | 124 | } |
| 125 | − url_fskip(pb, 26); /* VOC header */ | |
| 125 | + avio_seek(pb, 26, SEEK_CUR); /* VOC header */ | |
| 126 | 126 | ret = voc_get_packet(s, pkt, c93->audio, datasize - 26); |
| 127 | 127 | if (ret > 0) { |
| 128 | 128 | pkt->stream_index = 1; |
| @@ -114,22 +114,22 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size) · 113 unmodified lines | ||
| 114 | 114 | av_log(s, AV_LOG_ERROR, "invalid AAC magic cookie\n"); |
| 115 | 115 | return AVERROR_INVALIDDATA; |
| 116 | 116 | } |
| 117 | − url_fskip(pb, skip); | |
| 117 | + avio_seek(pb, skip, SEEK_CUR); | |
| 118 | 118 | } else if (st->codec->codec_id == CODEC_ID_ALAC) { |
| 119 | 119 | #define ALAC_PREAMBLE 12 |
| 120 | 120 | #define ALAC_HEADER 36 |
| 121 | 121 | if (size < ALAC_PREAMBLE + ALAC_HEADER) { |
| 122 | 122 | av_log(s, AV_LOG_ERROR, "invalid ALAC magic cookie\n"); |
| 123 | − url_fskip(pb, size); | |
| 123 | + avio_seek(pb, size, SEEK_CUR); | |
| 124 | 124 | return AVERROR_INVALIDDATA; |
| 125 | 125 | } |
| 126 | − url_fskip(pb, ALAC_PREAMBLE); | |
| 126 | + avio_seek(pb, ALAC_PREAMBLE, SEEK_CUR); | |
| 127 | 127 | st->codec->extradata = av_mallocz(ALAC_HEADER + FF_INPUT_BUFFER_PADDING_SIZE); |
| 128 | 128 | if (!st->codec->extradata) |
| 129 | 129 | return AVERROR(ENOMEM); |
| 130 | 130 | avio_read(pb, st->codec->extradata, ALAC_HEADER); |
| 131 | 131 | st->codec->extradata_size = ALAC_HEADER; |
| 132 | − url_fskip(pb, size - ALAC_PREAMBLE - ALAC_HEADER); | |
| 132 | + avio_seek(pb, size - ALAC_PREAMBLE - ALAC_HEADER, SEEK_CUR); | |
| 133 | 133 | } else { |
| 134 | 134 | st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE); |
| 135 | 135 | if (!st->codec->extradata) |
| @@ -201,7 +201,7 @@ static int read_header(AVFormatContext *s, · 65 unmodified lines | ||
| 201 | 201 | int found_data, ret; |
| 202 | 202 | int64_t size; |
| 203 | 203 | |
| 204 | − url_fskip(pb, 8); /* magic, version, file flags */ | |
| 204 | + avio_seek(pb, 8, SEEK_CUR); /* magic, version, file flags */ | |
| 205 | 205 | |
| 206 | 206 | /* audio description chunk */ |
| 207 | 207 | if (avio_rb32(pb) != MKBETAG('d','e','s','c')) { |
| @@ -233,11 +233,11 @@ static int read_header(AVFormatContext *s, · 25 unmodified lines | ||
| 233 | 233 | |
| 234 | 234 | switch (tag) { |
| 235 | 235 | case MKBETAG('d','a','t','a'): |
| 236 | − url_fskip(pb, 4); /* edit count */ | |
| 236 | + avio_seek(pb, 4, SEEK_CUR); /* edit count */ | |
| 237 | 237 | caf->data_start = url_ftell(pb); |
| 238 | 238 | caf->data_size = size < 0 ? -1 : size - 4; |
| 239 | 239 | if (caf->data_size > 0 && !url_is_streamed(pb)) |
| 240 | − url_fskip(pb, caf->data_size); | |
| 240 | + avio_seek(pb, caf->data_size, SEEK_CUR); | |
| 241 | 241 | found_data = 1; |
| 242 | 242 | break; |
| 243 | 243 | |
| @@ -265,7 +265,7 @@ static int read_header(AVFormatContext *s, · 21 unmodified lines | ||
| 265 | 265 | case MKBETAG('f','r','e','e'): |
| 266 | 266 | if (size < 0) |
| 267 | 267 | return AVERROR_INVALIDDATA; |
| 268 | − url_fskip(pb, size); | |
| 268 | + avio_seek(pb, size, SEEK_CUR); | |
| 269 | 269 | break; |
| 270 | 270 | } |
| 271 | 271 | } |
| @@ -96,7 +96,7 @@ static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap) · 95 unmodified lines | ||
| 96 | 96 | c->has_sound = 1; |
| 97 | 97 | size = avio_rb32(pb); |
| 98 | 98 | c->vidpos = url_ftell(pb) + size; |
| 99 | − url_fskip(pb, 16); | |
| 99 | + avio_seek(pb, 16, SEEK_CUR); | |
| 100 | 100 | fsize = avio_rl32(pb); |
| 101 | 101 | |
| 102 | 102 | ast = av_new_stream(s, 0); |
| @@ -108,7 +108,7 @@ static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap) · 5 unmodified lines | ||
| 108 | 108 | tag = avio_rl32(pb); |
| 109 | 109 | fsize = avio_rl32(pb); |
| 110 | 110 | if(tag == MKTAG('d', 'a', 't', 'a')) break; |
| 111 | − url_fskip(pb, fsize); | |
| 111 | + avio_seek(pb, fsize, SEEK_CUR); | |
| 112 | 112 | } |
| 113 | 113 | c->bpc = (fsize + c->frames - 1) / c->frames; |
| 114 | 114 | if(ast->codec->block_align) |
| @@ -62,7 +62,7 @@ static int cdata_read_header(AVFormatContext *s, AVFormatParameters *ap) · 61 unmodified lines | ||
| 62 | 62 | }; |
| 63 | 63 | |
| 64 | 64 | sample_rate = avio_rb16(pb); |
| 65 | − url_fskip(pb, 12); | |
| 65 | + avio_seek(pb, 12, SEEK_CUR); | |
| 66 | 66 | |
| 67 | 67 | st = av_new_stream(s, 0); |
| 68 | 68 | if (!st) |
| @@ -222,7 +222,7 @@ static int process_audio_header_eacs(AVFormatContext *s) · 221 unmodified lines | ||
| 222 | 222 | ea->bytes = avio_r8(pb); /* 1=8-bit, 2=16-bit */ |
| 223 | 223 | ea->num_channels = avio_r8(pb); |
| 224 | 224 | compression_type = avio_r8(pb); |
| 225 | − url_fskip(pb, 13); | |
| 225 | + avio_seek(pb, 13, SEEK_CUR); | |
| 226 | 226 | |
| 227 | 227 | switch (compression_type) { |
| 228 | 228 | case 0: |
| @@ -261,7 +261,7 @@ static int process_video_header_mdec(AVFormatContext *s) · 32 unmodified lines | ||
| 261 | 261 | { |
| 262 | 262 | EaDemuxContext *ea = s->priv_data; |
| 263 | 263 | AVIOContext *pb = s->pb; |
| 264 | − url_fskip(pb, 4); | |
| 264 | + avio_seek(pb, 4, SEEK_CUR); | |
| 265 | 265 | ea->width = avio_rl16(pb); |
| 266 | 266 | ea->height = avio_rl16(pb); |
| 267 | 267 | ea->time_base = (AVRational){1,15}; |
| @@ -274,7 +274,7 @@ static int process_video_header_vp6(AVFormatContext *s) · 6 unmodified lines | ||
| 274 | 274 | EaDemuxContext *ea = s->priv_data; |
| 275 | 275 | AVIOContext *pb = s->pb; |
| 276 | 276 | |
| 277 | − url_fskip(pb, 16); | |
| 277 | + avio_seek(pb, 16, SEEK_CUR); | |
| 278 | 278 | ea->time_base.den = avio_rl32(pb); |
| 279 | 279 | ea->time_base.num = avio_rl32(pb); |
| 280 | 280 | ea->video_codec = CODEC_ID_VP6; |
| @@ -316,7 +316,7 @@ static int process_ea_header(AVFormatContext *s) { · 35 unmodified lines | ||
| 316 | 316 | case SHEN_TAG : |
| 317 | 317 | blockid = avio_rl32(pb); |
| 318 | 318 | if (blockid == GSTR_TAG) { |
| 319 | − url_fskip(pb, 4); | |
| 319 | + avio_seek(pb, 4, SEEK_CUR); | |
| 320 | 320 | } else if ((blockid & 0xFFFF)!=PT00_TAG) { |
| 321 | 321 | av_log (s, AV_LOG_ERROR, "unknown SCHl headerid\n"); |
| 322 | 322 | return 0; |
| @@ -474,19 +474,19 @@ static int ea_read_packet(AVFormatContext *s, · 151 unmodified lines | ||
| 474 | 474 | /* audio data */ |
| 475 | 475 | case ISNh_TAG: |
| 476 | 476 | /* header chunk also contains data; skip over the header portion*/ |
| 477 | − url_fskip(pb, 32); | |
| 477 | + avio_seek(pb, 32, SEEK_CUR); | |
| 478 | 478 | chunk_size -= 32; |
| 479 | 479 | case ISNd_TAG: |
| 480 | 480 | case SCDl_TAG: |
| 481 | 481 | case SNDC_TAG: |
| 482 | 482 | case SDEN_TAG: |
| 483 | 483 | if (!ea->audio_codec) { |
| 484 | − url_fskip(pb, chunk_size); | |
| 484 | + avio_seek(pb, chunk_size, SEEK_CUR); | |
| 485 | 485 | break; |
| 486 | 486 | } else if (ea->audio_codec == CODEC_ID_PCM_S16LE_PLANAR || |
| 487 | 487 | ea->audio_codec == CODEC_ID_MP3) { |
| 488 | 488 | num_samples = avio_rl32(pb); |
| 489 | − url_fskip(pb, 8); | |
| 489 | + avio_seek(pb, 8, SEEK_CUR); | |
| 490 | 490 | chunk_size -= 12; |
| 491 | 491 | } |
| 492 | 492 | ret = av_get_packet(pb, pkt, chunk_size); |
| @@ -187,7 +187,7 @@ static int64_t get_dts(AVFormatContext *s, int64_t pos) · 186 unmodified lines | ||
| 187 | 187 | int64_t dts; |
| 188 | 188 | |
| 189 | 189 | ffm_seek1(s, pos); |
| 190 | − url_fskip(pb, 4); | |
| 190 | + avio_seek(pb, 4, SEEK_CUR); | |
| 191 | 191 | dts = avio_rb64(pb); |
| 192 | 192 | #ifdef DEBUG_SEEK |
| 193 | 193 | av_log(s, AV_LOG_DEBUG, "dts=%0.6f\n", dts / 1000000.0); |
| @@ -59,7 +59,7 @@ static int read_header(AVFormatContext *s, · 58 unmodified lines | ||
| 59 | 59 | return AVERROR_INVALIDDATA; |
| 60 | 60 | } |
| 61 | 61 | |
| 62 | − url_fskip(pb, 2); | |
| 62 | + avio_seek(pb, 2, SEEK_CUR); | |
| 63 | 63 | st->codec->codec_type = AVMEDIA_TYPE_VIDEO; |
| 64 | 64 | st->codec->codec_id = CODEC_ID_RAWVIDEO; |
| 65 | 65 | st->codec->pix_fmt = PIX_FMT_RGBA; |
| @@ -84,7 +84,7 @@ static int read_packet(AVFormatContext *s, · 18 unmodified lines | ||
| 84 | 84 | return AVERROR(EIO); |
| 85 | 85 | pkt->dts = url_ftell(s->pb) / (st->codec->width * (st->codec->height + film->leading) * 4); |
| 86 | 86 | pkt->size = av_get_packet(s->pb, pkt, st->codec->width * st->codec->height * 4); |
| 87 | − url_fskip(s->pb, st->codec->width * film->leading * 4); | |
| 87 | + avio_seek(s->pb, st->codec->width * film->leading * 4, SEEK_CUR); | |
| 88 | 88 | if (pkt->size < 0) |
| 89 | 89 | return pkt->size; |
| 90 | 90 | pkt->flags |= AV_PKT_FLAG_KEY; |
| @@ -113,7 +113,7 @@ static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_co · 112 unmodified lines | ||
| 113 | 113 | static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize) { |
| 114 | 114 | int length = avio_rb16(ioc); |
| 115 | 115 | if(length >= buffsize) { |
| 116 | − url_fskip(ioc, length); | |
| 116 | + avio_seek(ioc, length, SEEK_CUR); | |
| 117 | 117 | return -1; |
| 118 | 118 | } |
| 119 | 119 | |
| @@ -149,7 +149,7 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst · 29 unmodified lines | ||
| 149 | 149 | unsigned int keylen; |
| 150 | 150 | |
| 151 | 151 | while(url_ftell(ioc) < max_pos - 2 && (keylen = avio_rb16(ioc))) { |
| 152 | − url_fskip(ioc, keylen); //skip key string | |
| 152 | + avio_seek(ioc, keylen, SEEK_CUR); //skip key string | |
| 153 | 153 | if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0) |
| 154 | 154 | return -1; //if we couldn't skip, bomb out. |
| 155 | 155 | } |
| @@ -162,7 +162,7 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst · 6 unmodified lines | ||
| 162 | 162 | case AMF_DATA_TYPE_UNSUPPORTED: |
| 163 | 163 | break; //these take up no additional space |
| 164 | 164 | case AMF_DATA_TYPE_MIXEDARRAY: |
| 165 | − url_fskip(ioc, 4); //skip 32-bit max array index | |
| 165 | + avio_seek(ioc, 4, SEEK_CUR); //skip 32-bit max array index | |
| 166 | 166 | while(url_ftell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) { |
| 167 | 167 | //this is the only case in which we would want a nested parse to not skip over the object |
| 168 | 168 | if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0) |
| @@ -182,7 +182,7 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst · 13 unmodified lines | ||
| 182 | 182 | } |
| 183 | 183 | break; |
| 184 | 184 | case AMF_DATA_TYPE_DATE: |
| 185 | − url_fskip(ioc, 8 + 2); //timestamp (double) and UTC offset (int16) | |
| 185 | + avio_seek(ioc, 8 + 2, SEEK_CUR); //timestamp (double) and UTC offset (int16) | |
| 186 | 186 | break; |
| 187 | 187 | default: //unsupported type, we couldn't skip |
| 188 | 188 | return -1; |
| @@ -254,7 +254,7 @@ static int flv_read_header(AVFormatContext *s, · 65 unmodified lines | ||
| 254 | 254 | { |
| 255 | 255 | int offset, flags; |
| 256 | 256 | |
| 257 | − url_fskip(s->pb, 4); | |
| 257 | + avio_seek(s->pb, 4, SEEK_CUR); | |
| 258 | 258 | flags = avio_r8(s->pb); |
| 259 | 259 | /* old flvtool cleared this field */ |
| 260 | 260 | /* FIXME: better fix needed */ |
| @@ -278,7 +278,7 @@ static int flv_read_header(AVFormatContext *s, · 17 unmodified lines | ||
| 278 | 278 | |
| 279 | 279 | offset = avio_rb32(s->pb); |
| 280 | 280 | avio_seek(s->pb, offset, SEEK_SET); |
| 281 | − url_fskip(s->pb, 4); | |
| 281 | + avio_seek(s->pb, 4, SEEK_CUR); | |
| 282 | 282 | |
| 283 | 283 | s->start_time = 0; |
| 284 | 284 | |
| @@ -304,7 +304,7 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt) · 19 unmodified lines | ||
| 304 | 304 | int64_t dts, pts = AV_NOPTS_VALUE; |
| 305 | 305 | AVStream *st = NULL; |
| 306 | 306 | |
| 307 | − for(;;url_fskip(s->pb, 4)){ /* pkt size is repeated at end. skip it */ | |
| 307 | + for(;;avio_seek(s->pb, 4, SEEK_CUR)){ /* pkt size is repeated at end. skip it */ | |
| 308 | 308 | pos = url_ftell(s->pb); |
| 309 | 309 | type = avio_r8(s->pb); |
| 310 | 310 | size = avio_rb24(s->pb); |
| @@ -313,7 +313,7 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt) · 2 unmodified lines | ||
| 313 | 313 | // av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts); |
| 314 | 314 | if (url_feof(s->pb)) |
| 315 | 315 | return AVERROR_EOF; |
| 316 | − url_fskip(s->pb, 3); /* stream id, always 0 */ | |
| 316 | + avio_seek(s->pb, 3, SEEK_CUR); /* stream id, always 0 */ | |
| 317 | 317 | flags = 0; |
| 318 | 318 | |
| 319 | 319 | if(size == 0) |
| @@ -454,7 +454,7 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt) · 134 unmodified lines | ||
| 454 | 454 | pkt->flags |= AV_PKT_FLAG_KEY; |
| 455 | 455 | |
| 456 | 456 | leave: |
| 457 | − url_fskip(s->pb, 4); | |
| 457 | + avio_seek(s->pb, 4, SEEK_CUR); | |
| 458 | 458 | return ret; |
| 459 | 459 | } |
| 460 | 460 | |
| @@ -174,7 +174,7 @@ static void gxf_material_tags(AVIOContext *pb, int *len, struct gxf_stream_info · 173 unmodified lines | ||
| 174 | 174 | else if (tag == MAT_LAST_FIELD) |
| 175 | 175 | si->last_field = value; |
| 176 | 176 | } else |
| 177 | − url_fskip(pb, tlen); | |
| 177 | + avio_seek(pb, tlen, SEEK_CUR); | |
| 178 | 178 | } |
| 179 | 179 | } |
| 180 | 180 | |
| @@ -223,7 +223,7 @@ static void gxf_track_tags(AVIOContext *pb, int *len, struct gxf_stream_info *si · 42 unmodified lines | ||
| 223 | 223 | else if (tag == TRACK_FPF && (value == 1 || value == 2)) |
| 224 | 224 | si->fields_per_frame = value; |
| 225 | 225 | } else |
| 226 | − url_fskip(pb, tlen); | |
| 226 | + avio_seek(pb, tlen, SEEK_CUR); | |
| 227 | 227 | } |
| 228 | 228 | } |
| 229 | 229 | |
| @@ -238,7 +238,7 @@ static void gxf_read_index(AVFormatContext *s, int pkt_len) { · 8 unmodified lines | ||
| 238 | 238 | int i; |
| 239 | 239 | pkt_len -= 8; |
| 240 | 240 | if (s->flags & AVFMT_FLAG_IGNIDX) { |
| 241 | − url_fskip(pb, pkt_len); | |
| 241 | + avio_seek(pb, pkt_len, SEEK_CUR); | |
| 242 | 242 | return; |
| 243 | 243 | } |
| 244 | 244 | if (map_cnt > 1000) { |
| @@ -247,7 +247,7 @@ static void gxf_read_index(AVFormatContext *s, int pkt_len) { · 2 unmodified lines | ||
| 247 | 247 | } |
| 248 | 248 | if (pkt_len < 4 * map_cnt) { |
| 249 | 249 | av_log(s, AV_LOG_ERROR, "invalid index length\n"); |
| 250 | − url_fskip(pb, pkt_len); | |
| 250 | + avio_seek(pb, pkt_len, SEEK_CUR); | |
| 251 | 251 | return; |
| 252 | 252 | } |
| 253 | 253 | pkt_len -= 4 * map_cnt; |
| @@ -255,7 +255,7 @@ static void gxf_read_index(AVFormatContext *s, int pkt_len) { · 1 unmodified line | ||
| 255 | 255 | for (i = 0; i < map_cnt; i++) |
| 256 | 256 | av_add_index_entry(st, (uint64_t)avio_rl32(pb) * 1024, |
| 257 | 257 | i * (uint64_t)fields_per_map + 1, 0, 0, 0); |
| 258 | − url_fskip(pb, pkt_len); | |
| 258 | + avio_seek(pb, pkt_len, SEEK_CUR); | |
| 259 | 259 | } |
| 260 | 260 | |
| 261 | 261 | static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) { |
| @@ -283,7 +283,7 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) { · 21 unmodified lines | ||
| 283 | 283 | } |
| 284 | 284 | map_len -= len; |
| 285 | 285 | gxf_material_tags(pb, &len, &si); |
| 286 | − url_fskip(pb, len); | |
| 286 | + avio_seek(pb, len, SEEK_CUR); | |
| 287 | 287 | map_len -= 2; |
| 288 | 288 | len = avio_rb16(pb); // length of track description |
| 289 | 289 | if (len > map_len) { |
| @@ -301,7 +301,7 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) { · 11 unmodified lines | ||
| 301 | 301 | track_len = avio_rb16(pb); |
| 302 | 302 | len -= track_len; |
| 303 | 303 | gxf_track_tags(pb, &track_len, &si); |
| 304 | − url_fskip(pb, track_len); | |
| 304 | + avio_seek(pb, track_len, SEEK_CUR); | |
| 305 | 305 | if (!(track_type & 0x80)) { |
| 306 | 306 | av_log(s, AV_LOG_ERROR, "invalid track type %x\n", track_type); |
| 307 | 307 | continue; |
| @@ -326,7 +326,7 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) { · 18 unmodified lines | ||
| 326 | 326 | if (len < 0) |
| 327 | 327 | av_log(s, AV_LOG_ERROR, "invalid track description length specified\n"); |
| 328 | 328 | if (map_len) |
| 329 | − url_fskip(pb, map_len); | |
| 329 | + avio_seek(pb, map_len, SEEK_CUR); | |
| 330 | 330 | if (!parse_packet_header(pb, &pkt_type, &len)) { |
| 331 | 331 | av_log(s, AV_LOG_ERROR, "sync lost in header\n"); |
| 332 | 332 | return -1; |
| @@ -342,8 +342,8 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) { · 9 unmodified lines | ||
| 342 | 342 | if (len >= 0x39) { |
| 343 | 343 | AVRational fps; |
| 344 | 344 | len -= 0x39; |
| 345 | − url_fskip(pb, 5); // preamble | |
| 346 | − url_fskip(pb, 0x30); // payload description | |
| 345 | + avio_seek(pb, 5, SEEK_CUR); // preamble | |
| 346 | + avio_seek(pb, 0x30, SEEK_CUR); // payload description | |
| 347 | 347 | fps = fps_umf2avr(avio_rl32(pb)); |
| 348 | 348 | if (!main_timebase.num || !main_timebase.den) { |
| 349 | 349 | // this may not always be correct, but simply the best we can get |
| @@ -354,7 +354,7 @@ static int gxf_header(AVFormatContext *s, AVFormatParameters *ap) { · 4 unmodified lines | ||
| 354 | 354 | av_log(s, AV_LOG_INFO, "UMF packet too short\n"); |
| 355 | 355 | } else |
| 356 | 356 | av_log(s, AV_LOG_INFO, "UMF packet missing\n"); |
| 357 | − url_fskip(pb, len); | |
| 357 | + avio_seek(pb, len, SEEK_CUR); | |
| 358 | 358 | // set a fallback value, 60000/1001 is specified for audio-only files |
| 359 | 359 | // so use that regardless of why we do not know the video frame rate. |
| 360 | 360 | if (!main_timebase.num || !main_timebase.den) |
| @@ -437,7 +437,7 @@ static int gxf_packet(AVFormatContext *s, AVPacket *pkt) { · 76 unmodified lines | ||
| 437 | 437 | continue; |
| 438 | 438 | } |
| 439 | 439 | if (pkt_type != PKT_MEDIA) { |
| 440 | − url_fskip(pb, pkt_len); | |
| 440 | + avio_seek(pb, pkt_len, SEEK_CUR); | |
| 441 | 441 | continue; |
| 442 | 442 | } |
| 443 | 443 | if (pkt_len < 16) { |
| @@ -462,7 +462,7 @@ static int gxf_packet(AVFormatContext *s, AVPacket *pkt) { · 18 unmodified lines | ||
| 462 | 462 | int last = field_info & 0xffff; // last is exclusive |
| 463 | 463 | int bps = av_get_bits_per_sample(st->codec->codec_id)>>3; |
| 464 | 464 | if (first <= last && last*bps <= pkt_len) { |
| 465 | − url_fskip(pb, first*bps); | |
| 465 | + avio_seek(pb, first*bps, SEEK_CUR); | |
| 466 | 466 | skip = pkt_len - last*bps; |
| 467 | 467 | pkt_len = (last-first)*bps; |
| 468 | 468 | } else |
| @@ -470,7 +470,7 @@ static int gxf_packet(AVFormatContext *s, AVPacket *pkt) { · 1 unmodified line | ||
| 470 | 470 | } |
| 471 | 471 | ret = av_get_packet(pb, pkt, pkt_len); |
| 472 | 472 | if (skip) |
| 473 | − url_fskip(pb, skip); | |
| 473 | + avio_seek(pb, skip, SEEK_CUR); | |
| 474 | 474 | pkt->stream_index = stream_index; |
| 475 | 475 | pkt->dts = field_nr; |
| 476 | 476 | return ret; |
| @@ -171,7 +171,7 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t · 170 unmodified lines | ||
| 171 | 171 | unsync = flags & 0x80; |
| 172 | 172 | |
| 173 | 173 | if (isv34 && flags & 0x40) /* Extended header present, just skip over it */ |
| 174 | − url_fskip(s->pb, get_size(s->pb, 4)); | |
| 174 | + avio_seek(s->pb, get_size(s->pb, 4), SEEK_CUR); | |
| 175 | 175 | |
| 176 | 176 | while (len >= taghdrlen) { |
| 177 | 177 | unsigned int tflags; |
| @@ -205,7 +205,7 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t · 27 unmodified lines | ||
| 205 | 205 | |
| 206 | 206 | if (tflags & (ID3v2_FLAG_ENCRYPTION | ID3v2_FLAG_COMPRESSION)) { |
| 207 | 207 | av_log(s, AV_LOG_WARNING, "Skipping encrypted/compressed ID3v2 frame %s.\n", tag); |
| 208 | − url_fskip(s->pb, tlen); | |
| 208 | + avio_seek(s->pb, tlen, SEEK_CUR); | |
| 209 | 209 | } else if (tag[0] == 'T') { |
| 210 | 210 | if (unsync || tunsync) { |
| 211 | 211 | int i, j; |
| @@ -226,7 +226,7 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t · 14 unmodified lines | ||
| 226 | 226 | else if (!tag[0]) { |
| 227 | 227 | if (tag[1]) |
| 228 | 228 | av_log(s, AV_LOG_WARNING, "invalid frame id, assuming padding"); |
| 229 | − url_fskip(s->pb, tlen); | |
| 229 | + avio_seek(s->pb, tlen, SEEK_CUR); | |
| 230 | 230 | break; |
| 231 | 231 | } |
| 232 | 232 | /* Skip to end of tag */ |
| @@ -235,17 +235,17 @@ static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t · 2 unmodified lines | ||
| 235 | 235 | |
| 236 | 236 | if (len > 0) { |
| 237 | 237 | /* Skip padding */ |
| 238 | − url_fskip(s->pb, len); | |
| 238 | + avio_seek(s->pb, len, SEEK_CUR); | |
| 239 | 239 | } |
| 240 | 240 | if (version == 4 && flags & 0x10) /* Footer preset, always 10 bytes, skip over it */ |
| 241 | − url_fskip(s->pb, 10); | |
| 241 | + avio_seek(s->pb, 10, SEEK_CUR); | |
| 242 | 242 | |
| 243 | 243 | av_free(buffer); |
| 244 | 244 | return; |
| 245 | 245 | |
| 246 | 246 | error: |
| 247 | 247 | av_log(s, AV_LOG_INFO, "ID3v2.%d tag skipped, cannot handle %s\n", version, reason); |
| 248 | − url_fskip(s->pb, len); | |
| 248 | + avio_seek(s->pb, len, SEEK_CUR); | |
| 249 | 249 | av_free(buffer); |
| 250 | 250 | } |
| 251 | 251 | |
| @@ -134,7 +134,7 @@ static int iff_read_header(AVFormatContext *s, · 133 unmodified lines | ||
| 134 | 134 | return AVERROR(ENOMEM); |
| 135 | 135 | |
| 136 | 136 | st->codec->channels = 1; |
| 137 | − url_fskip(pb, 8); | |
| 137 | + avio_seek(pb, 8, SEEK_CUR); | |
| 138 | 138 | // codec_tag used by ByteRun1 decoder to distinguish progressive (PBM) and interlaced (ILBM) content |
| 139 | 139 | st->codec->codec_tag = avio_rl32(pb); |
| 140 | 140 | |
| @@ -152,10 +152,10 @@ static int iff_read_header(AVFormatContext *s, · 11 unmodified lines | ||
| 152 | 152 | |
| 153 | 153 | if (data_size < 14) |
| 154 | 154 | return AVERROR_INVALIDDATA; |
| 155 | − url_fskip(pb, 12); | |
| 155 | + avio_seek(pb, 12, SEEK_CUR); | |
| 156 | 156 | st->codec->sample_rate = avio_rb16(pb); |
| 157 | 157 | if (data_size >= 16) { |
| 158 | − url_fskip(pb, 1); | |
| 158 | + avio_seek(pb, 1, SEEK_CUR); | |
| 159 | 159 | compression = avio_r8(pb); |
| 160 | 160 | } |
| 161 | 161 | break; |
| @@ -186,14 +186,14 @@ static int iff_read_header(AVFormatContext *s, · 24 unmodified lines | ||
| 186 | 186 | return AVERROR_INVALIDDATA; |
| 187 | 187 | st->codec->width = avio_rb16(pb); |
| 188 | 188 | st->codec->height = avio_rb16(pb); |
| 189 | − url_fskip(pb, 4); // x, y offset | |
| 189 | + avio_seek(pb, 4, SEEK_CUR); // x, y offset | |
| 190 | 190 | st->codec->bits_per_coded_sample = avio_r8(pb); |
| 191 | 191 | if (data_size >= 11) { |
| 192 | − url_fskip(pb, 1); // masking | |
| 192 | + avio_seek(pb, 1, SEEK_CUR); // masking | |
| 193 | 193 | compression = avio_r8(pb); |
| 194 | 194 | } |
| 195 | 195 | if (data_size >= 16) { |
| 196 | − url_fskip(pb, 3); // paddding, transparent | |
| 196 | + avio_seek(pb, 3, SEEK_CUR); // paddding, transparent | |
| 197 | 197 | st->sample_aspect_ratio.num = avio_r8(pb); |
| 198 | 198 | st->sample_aspect_ratio.den = avio_r8(pb); |
| 199 | 199 | } |
| @@ -223,7 +223,7 @@ static int iff_read_header(AVFormatContext *s, · 23 unmodified lines | ||
| 223 | 223 | return res; |
| 224 | 224 | } |
| 225 | 225 | } |
| 226 | − url_fskip(pb, data_size - (url_ftell(pb) - orig_pos) + (data_size & 1)); | |
| 226 | + avio_seek(pb, data_size - (url_ftell(pb) - orig_pos) + (data_size & 1), SEEK_CUR); | |
| 227 | 227 | } |
| 228 | 228 | |
| 229 | 229 | avio_seek(pb, iff->body_pos, SEEK_SET); |
| @@ -35,11 +35,11 @@ static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt) · 34 unmodified lines | ||
| 35 | 35 | w = avio_rl16(s->pb); |
| 36 | 36 | h = avio_rl16(s->pb); |
| 37 | 37 | |
| 38 | − url_fskip(s->pb, 8); // zero + size (padded?) | |
| 39 | − url_fskip(s->pb, 2); | |
| 38 | + avio_seek(s->pb, 8, SEEK_CUR); // zero + size (padded?) | |
| 39 | + avio_seek(s->pb, 2, SEEK_CUR); | |
| 40 | 40 | unk1 = avio_rl16(s->pb); |
| 41 | 41 | unk2 = avio_rl16(s->pb); |
| 42 | − url_fskip(s->pb, 22); // ASCII timestamp | |
| 42 | + avio_seek(s->pb, 22, SEEK_CUR); // ASCII timestamp | |
| 43 | 43 | |
| 44 | 44 | av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n", |
| 45 | 45 | size, w, h, unk1, unk2); |
| @@ -70,7 +70,7 @@ retry: · 69 unmodified lines | ||
| 70 | 70 | return -1; |
| 71 | 71 | |
| 72 | 72 | if(type==258){ |
| 73 | − url_fskip(s->pb, size); | |
| 73 | + avio_seek(s->pb, size, SEEK_CUR); | |
| 74 | 74 | goto retry; |
| 75 | 75 | } |
| 76 | 76 | |
| @@ -100,7 +100,7 @@ static int lmlm4_read_packet(AVFormatContext *s, AVPacket *pkt) { · 99 unmodified lines | ||
| 100 | 100 | if ((ret = av_get_packet(pb, pkt, frame_size)) <= 0) |
| 101 | 101 | return AVERROR(EIO); |
| 102 | 102 | |
| 103 | − url_fskip(pb, padding); | |
| 103 | + avio_seek(pb, padding, SEEK_CUR); | |
| 104 | 104 | |
| 105 | 105 | switch (frame_type) { |
| 106 | 106 | case LMLM4_I_FRAME: |
| @@ -137,8 +137,8 @@ static int get_packet_header(AVFormatContext *s, uint8_t *header, uint32_t *form · 136 unmodified lines | ||
| 137 | 137 | case 0: |
| 138 | 138 | //video |
| 139 | 139 | //skip VBI data and metadata |
| 140 | − url_fskip(pb, (int64_t)(uint32_t)AV_RL32(&header[44]) + | |
| 141 | − (int64_t)(uint32_t)AV_RL32(&header[52])); | |
| 140 | + avio_seek(pb, (int64_t)(uint32_t)AV_RL32(&header[44]) + | |
| 141 | + (int64_t)(uint32_t)AV_RL32(&header[52]), SEEK_CUR); | |
| 142 | 142 | break; |
| 143 | 143 | case 1: |
| 144 | 144 | //audio |
| @@ -255,7 +255,7 @@ static int lxf_read_header(AVFormatContext *s, AVFormatParameters *ap) · 110 unmodified lines | ||
| 255 | 255 | |
| 256 | 256 | if (format == 1) { |
| 257 | 257 | //skip extended field data |
| 258 | − url_fskip(s->pb, (uint32_t)AV_RL32(&header[40])); | |
| 258 | + avio_seek(s->pb, (uint32_t)AV_RL32(&header[40]), SEEK_CUR); | |
| 259 | 259 | } |
| 260 | 260 | |
| 261 | 261 | return 0; |
| @@ -1393,10 +1393,10 @@ static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap) · 1392 unmodified lines | ||
| 1393 | 1393 | int flavor; |
| 1394 | 1394 | ffio_init_context(&b, track->codec_priv.data,track->codec_priv.size, |
| 1395 | 1395 | 0, NULL, NULL, NULL, NULL); |
| 1396 | − url_fskip(&b, 22); | |
| 1396 | + avio_seek(&b, 22, SEEK_CUR); | |
| 1397 | 1397 | flavor = avio_rb16(&b); |
| 1398 | 1398 | track->audio.coded_framesize = avio_rb32(&b); |
| 1399 | − url_fskip(&b, 12); | |
| 1399 | + avio_seek(&b, 12, SEEK_CUR); | |
| 1400 | 1400 | track->audio.sub_packet_h = avio_rb16(&b); |
| 1401 | 1401 | track->audio.frame_size = avio_rb16(&b); |
| 1402 | 1402 | track->audio.sub_packet_size = avio_rb16(&b); |
| @@ -296,7 +296,7 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 295 unmodified lines | ||
| 296 | 296 | parse = mov_read_udta_string; |
| 297 | 297 | |
| 298 | 298 | if (!parse) { /* skip leaf atoms data */ |
| 299 | − url_fskip(pb, a.size); | |
| 299 | + avio_seek(pb, a.size, SEEK_CUR); | |
| 300 | 300 | } else { |
| 301 | 301 | int64_t start_pos = url_ftell(pb); |
| 302 | 302 | int64_t left; |
| @@ -308,14 +308,14 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 5 unmodified lines | ||
| 308 | 308 | return 0; |
| 309 | 309 | left = a.size - url_ftell(pb) + start_pos; |
| 310 | 310 | if (left > 0) /* skip garbage at atom end */ |
| 311 | − url_fskip(pb, left); | |
| 311 | + avio_seek(pb, left, SEEK_CUR); | |
| 312 | 312 | } |
| 313 | 313 | |
| 314 | 314 | total_size += a.size; |
| 315 | 315 | } |
| 316 | 316 | |
| 317 | 317 | if (total_size < atom.size && atom.size < 0x7ffff) |
| 318 | − url_fskip(pb, atom.size - total_size); | |
| 318 | + avio_seek(pb, atom.size - total_size, SEEK_CUR); | |
| 319 | 319 | |
| 320 | 320 | return 0; |
| 321 | 321 | } |
| @@ -357,7 +357,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 35 unmodified lines | ||
| 357 | 357 | uint16_t volume_len, len; |
| 358 | 358 | int16_t type; |
| 359 | 359 | |
| 360 | − url_fskip(pb, 10); | |
| 360 | + avio_seek(pb, 10, SEEK_CUR); | |
| 361 | 361 | |
| 362 | 362 | volume_len = avio_r8(pb); |
| 363 | 363 | volume_len = FFMIN(volume_len, 27); |
| @@ -365,7 +365,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 1 unmodified line | ||
| 365 | 365 | dref->volume[volume_len] = 0; |
| 366 | 366 | av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len); |
| 367 | 367 | |
| 368 | − url_fskip(pb, 12); | |
| 368 | + avio_seek(pb, 12, SEEK_CUR); | |
| 369 | 369 | |
| 370 | 370 | len = avio_r8(pb); |
| 371 | 371 | len = FFMIN(len, 63); |
| @@ -373,7 +373,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 1 unmodified line | ||
| 373 | 373 | dref->filename[len] = 0; |
| 374 | 374 | av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len); |
| 375 | 375 | |
| 376 | − url_fskip(pb, 16); | |
| 376 | + avio_seek(pb, 16, SEEK_CUR); | |
| 377 | 377 | |
| 378 | 378 | /* read next level up_from_alias/down_to_target */ |
| 379 | 379 | dref->nlvl_from = avio_rb16(pb); |
| @@ -381,7 +381,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 1 unmodified line | ||
| 381 | 381 | av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n", |
| 382 | 382 | dref->nlvl_from, dref->nlvl_to); |
| 383 | 383 | |
| 384 | − url_fskip(pb, 16); | |
| 384 | + avio_seek(pb, 16, SEEK_CUR); | |
| 385 | 385 | |
| 386 | 386 | for (type = 0; type != -1 && url_ftell(pb) < next; ) { |
| 387 | 387 | type = avio_rb16(pb); |
| @@ -416,7 +416,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 28 unmodified lines | ||
| 416 | 416 | dref->dir[j] = '/'; |
| 417 | 417 | av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir); |
| 418 | 418 | } else |
| 419 | − url_fskip(pb, len); | |
| 419 | + avio_seek(pb, len, SEEK_CUR); | |
| 420 | 420 | } |
| 421 | 421 | } |
| 422 | 422 | avio_seek(pb, next, SEEK_SET); |
| @@ -663,9 +663,9 @@ static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 240 unmodified lines | ||
| 663 | 663 | |
| 664 | 664 | avio_rb16(pb); /* preferred volume */ |
| 665 | 665 | |
| 666 | − url_fskip(pb, 10); /* reserved */ | |
| 666 | + avio_seek(pb, 10, SEEK_CUR); /* reserved */ | |
| 667 | 667 | |
| 668 | − url_fskip(pb, 36); /* display matrix */ | |
| 668 | + avio_seek(pb, 36, SEEK_CUR); /* display matrix */ | |
| 669 | 669 | |
| 670 | 670 | avio_rb32(pb); /* preview time */ |
| 671 | 671 | avio_rb32(pb); /* preview duration */ |
| @@ -782,7 +782,7 @@ static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 110 unmodified lines | ||
| 782 | 782 | if (mov_read_default(c, pb, atom) < 0) |
| 783 | 783 | return -1; |
| 784 | 784 | } else |
| 785 | − url_fskip(pb, atom.size); | |
| 785 | + avio_seek(pb, atom.size, SEEK_CUR); | |
| 786 | 786 | return 0; |
| 787 | 787 | } |
| 788 | 788 | |
| @@ -833,7 +833,7 @@ static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 44 unmodified lines | ||
| 833 | 833 | if (!st->codec->extradata) |
| 834 | 834 | return AVERROR(ENOMEM); |
| 835 | 835 | st->codec->extradata_size = atom.size - 40; |
| 836 | − url_fskip(pb, 40); | |
| 836 | + avio_seek(pb, 40, SEEK_CUR); | |
| 837 | 837 | avio_read(pb, st->codec->extradata, atom.size - 40); |
| 838 | 838 | return 0; |
| 839 | 839 | } |
| @@ -945,7 +945,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries) · 105 unmodified lines | ||
| 945 | 945 | * in the MOV demuxer, patch welcome. */ |
| 946 | 946 | multiple_stsd: |
| 947 | 947 | av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n"); |
| 948 | − url_fskip(pb, size - (url_ftell(pb) - start_pos)); | |
| 948 | + avio_seek(pb, size - (url_ftell(pb) - start_pos), SEEK_CUR); | |
| 949 | 949 | continue; |
| 950 | 950 | } |
| 951 | 951 | /* we cannot demux concatenated h264 streams because of different extradata */ |
| @@ -1003,7 +1003,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries) · 51 unmodified lines | ||
| 1003 | 1003 | len = 31; |
| 1004 | 1004 | mov_read_mac_string(c, pb, len, st->codec->codec_name, 32); |
| 1005 | 1005 | if (len < 31) |
| 1006 | − url_fskip(pb, 31 - len); | |
| 1006 | + avio_seek(pb, 31 - len, SEEK_CUR); | |
| 1007 | 1007 | /* codec_tag YV12 triggers an UV swap in rawdec.c */ |
| 1008 | 1008 | if (!memcmp(st->codec->codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) |
| 1009 | 1009 | st->codec->codec_tag=MKTAG('I', '4', '2', '0'); |
| @@ -1174,7 +1174,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries) · 164 unmodified lines | ||
| 1174 | 1174 | st->codec->height = sc->height; |
| 1175 | 1175 | } else { |
| 1176 | 1176 | /* other codec type, just skip (rtp, mp4s, tmcd ...) */ |
| 1177 | − url_fskip(pb, size - (url_ftell(pb) - start_pos)); | |
| 1177 | + avio_seek(pb, size - (url_ftell(pb) - start_pos), SEEK_CUR); | |
| 1178 | 1178 | } |
| 1179 | 1179 | /* this will read extra atoms at the end (wave, alac, damr, avcC, SMI ...) */ |
| 1180 | 1180 | a.size = size - (url_ftell(pb) - start_pos); |
| @@ -1182,7 +1182,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries) · 1 unmodified line | ||
| 1182 | 1182 | if (mov_read_default(c, pb, a) < 0) |
| 1183 | 1183 | return -1; |
| 1184 | 1184 | } else if (a.size > 0) |
| 1185 | − url_fskip(pb, a.size); | |
| 1185 | + avio_seek(pb, a.size, SEEK_CUR); | |
| 1186 | 1186 | } |
| 1187 | 1187 | |
| 1188 | 1188 | if(st->codec->codec_type==AVMEDIA_TYPE_AUDIO && st->codec->sample_rate==0 && sc->time_scale>1) |
| @@ -2078,13 +2078,13 @@ static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom) · 889 unmodified lines | ||
| 2078 | 2078 | if (atom.size < 8) |
| 2079 | 2079 | return 0; /* continue */ |
| 2080 | 2080 | if (avio_rb32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */ |
| 2081 | − url_fskip(pb, atom.size - 4); | |
| 2081 | + avio_seek(pb, atom.size - 4, SEEK_CUR); | |
| 2082 | 2082 | return 0; |
| 2083 | 2083 | } |
| 2084 | 2084 | atom.type = avio_rl32(pb); |
| 2085 | 2085 | atom.size -= 8; |
| 2086 | 2086 | if (atom.type != MKTAG('m','d','a','t')) { |
| 2087 | − url_fskip(pb, atom.size); | |
| 2087 | + avio_seek(pb, atom.size, SEEK_CUR); | |
| 2088 | 2088 | return 0; |
| 2089 | 2089 | } |
| 2090 | 2090 | err = mov_read_mdat(c, pb, atom); |
| @@ -182,7 +182,7 @@ static void mpc8_handle_chunk(AVFormatContext *s, int tag, int64_t chunk_pos, in · 181 unmodified lines | ||
| 182 | 182 | avio_seek(pb, pos, SEEK_SET); |
| 183 | 183 | break; |
| 184 | 184 | default: |
| 185 | − url_fskip(pb, size); | |
| 185 | + avio_seek(pb, size, SEEK_CUR); | |
| 186 | 186 | } |
| 187 | 187 | } |
| 188 | 188 | |
| @@ -212,7 +212,7 @@ static int mpc8_read_header(AVFormatContext *s, AVFormatParameters *ap) · 23 unmodified lines | ||
| 212 | 212 | return -1; |
| 213 | 213 | } |
| 214 | 214 | pos = url_ftell(pb); |
| 215 | − url_fskip(pb, 4); //CRC | |
| 215 | + avio_seek(pb, 4, SEEK_CUR); //CRC | |
| 216 | 216 | c->ver = avio_r8(pb); |
| 217 | 217 | if(c->ver != 8){ |
| 218 | 218 | av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver); |
| @@ -212,7 +212,7 @@ static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb) · 211 unmodified lines | ||
| 212 | 212 | ps_info_length = avio_rb16(pb); |
| 213 | 213 | |
| 214 | 214 | /* skip program_stream_info */ |
| 215 | − url_fskip(pb, ps_info_length); | |
| 215 | + avio_seek(pb, ps_info_length, SEEK_CUR); | |
| 216 | 216 | es_map_length = avio_rb16(pb); |
| 217 | 217 | |
| 218 | 218 | /* at least one es available? */ |
| @@ -223,7 +223,7 @@ static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb) · 4 unmodified lines | ||
| 223 | 223 | /* remember mapping from stream id to stream type */ |
| 224 | 224 | m->psm_es_type[es_id] = type; |
| 225 | 225 | /* skip program_stream_info */ |
| 226 | − url_fskip(pb, es_info_length); | |
| 226 | + avio_seek(pb, es_info_length, SEEK_CUR); | |
| 227 | 227 | es_map_length -= 4 + es_info_length; |
| 228 | 228 | } |
| 229 | 229 | avio_rb32(pb); /* crc32 */ |
| @@ -264,7 +264,7 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 34 unmodified lines | ||
| 264 | 264 | if (startcode == SYSTEM_HEADER_START_CODE) |
| 265 | 265 | goto redo; |
| 266 | 266 | if (startcode == PADDING_STREAM) { |
| 267 | − url_fskip(s->pb, avio_rb16(s->pb)); | |
| 267 | + avio_seek(s->pb, avio_rb16(s->pb), SEEK_CUR); | |
| 268 | 268 | goto redo; |
| 269 | 269 | } |
| 270 | 270 | if (startcode == PRIVATE_STREAM_2) { |
| @@ -281,7 +281,7 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 10 unmodified lines | ||
| 281 | 281 | } |
| 282 | 282 | m->sofdec -= !m->sofdec; |
| 283 | 283 | } |
| 284 | − url_fskip(s->pb, len); | |
| 284 | + avio_seek(s->pb, len, SEEK_CUR); | |
| 285 | 285 | goto redo; |
| 286 | 286 | } |
| 287 | 287 | if (startcode == PROGRAM_STREAM_MAP) { |
| @@ -359,7 +359,7 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 71 unmodified lines | ||
| 359 | 359 | av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext); |
| 360 | 360 | pes_ext=skip=0; |
| 361 | 361 | } |
| 362 | − url_fskip(s->pb, skip); | |
| 362 | + avio_seek(s->pb, skip, SEEK_CUR); | |
| 363 | 363 | header_len -= skip; |
| 364 | 364 | |
| 365 | 365 | if (pes_ext & 0x01) { /* PES extension 2 */ |
| @@ -375,7 +375,7 @@ static int mpegps_read_pes_header(AVFormatContext *s, · 9 unmodified lines | ||
| 375 | 375 | } |
| 376 | 376 | if(header_len < 0) |
| 377 | 377 | goto error_redo; |
| 378 | − url_fskip(s->pb, header_len); | |
| 378 | + avio_seek(s->pb, header_len, SEEK_CUR); | |
| 379 | 379 | } |
| 380 | 380 | else if( c!= 0xf ) |
| 381 | 381 | goto redo; |
| @@ -433,7 +433,7 @@ static int mpegps_read_packet(AVFormatContext *s, · 51 unmodified lines | ||
| 433 | 433 | |
| 434 | 434 | if(startcode == 0x1bd) { |
| 435 | 435 | dvdaudio_substream_type = avio_r8(s->pb); |
| 436 | − url_fskip(s->pb, 3); | |
| 436 | + avio_seek(s->pb, 3, SEEK_CUR); | |
| 437 | 437 | len -= 4; |
| 438 | 438 | } |
| 439 | 439 | |
| @@ -525,7 +525,7 @@ static int mpegps_read_packet(AVFormatContext *s, · 85 unmodified lines | ||
| 525 | 525 | } else { |
| 526 | 526 | skip: |
| 527 | 527 | /* skip packet */ |
| 528 | − url_fskip(s->pb, len); | |
| 528 | + avio_seek(s->pb, len, SEEK_CUR); | |
| 529 | 529 | goto redo; |
| 530 | 530 | } |
| 531 | 531 | /* no stream found: add a new stream */ |
| @@ -602,7 +602,7 @@ static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, · 70 unmodified lines | ||
| 602 | 602 | dts != AV_NOPTS_VALUE) { |
| 603 | 603 | break; |
| 604 | 604 | } |
| 605 | − url_fskip(s->pb, len); | |
| 605 | + avio_seek(s->pb, len, SEEK_CUR); | |
| 606 | 606 | } |
| 607 | 607 | #ifdef DEBUG_SEEK |
| 608 | 608 | printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0); |
| @@ -1346,7 +1346,7 @@ static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size) · 1345 unmodified lines | ||
| 1346 | 1346 | } else { |
| 1347 | 1347 | skip = raw_packet_size - TS_PACKET_SIZE; |
| 1348 | 1348 | if (skip > 0) |
| 1349 | − url_fskip(pb, skip); | |
| 1349 | + avio_seek(pb, skip, SEEK_CUR); | |
| 1350 | 1350 | break; |
| 1351 | 1351 | } |
| 1352 | 1352 | } |
| @@ -104,19 +104,19 @@ static int msnwc_tcp_read_packet(AVFormatContext *ctx, AVPacket *pkt) · 103 unmodified lines | ||
| 104 | 104 | uint16_t keyframe; |
| 105 | 105 | uint32_t size, timestamp; |
| 106 | 106 | |
| 107 | − url_fskip(pb, 1); /* one byte has been read ahead */ | |
| 108 | − url_fskip(pb, 2); | |
| 109 | − url_fskip(pb, 2); | |
| 107 | + avio_seek(pb, 1, SEEK_CUR); /* one byte has been read ahead */ | |
| 108 | + avio_seek(pb, 2, SEEK_CUR); | |
| 109 | + avio_seek(pb, 2, SEEK_CUR); | |
| 110 | 110 | keyframe = avio_rl16(pb); |
| 111 | 111 | size = avio_rl32(pb); |
| 112 | − url_fskip(pb, 4); | |
| 113 | − url_fskip(pb, 4); | |
| 112 | + avio_seek(pb, 4, SEEK_CUR); | |
| 113 | + avio_seek(pb, 4, SEEK_CUR); | |
| 114 | 114 | timestamp = avio_rl32(pb); |
| 115 | 115 | |
| 116 | 116 | if(!size || av_get_packet(pb, pkt, size) != size) |
| 117 | 117 | return -1; |
| 118 | 118 | |
| 119 | − url_fskip(pb, 1); /* Read ahead one byte of struct size like read_header */ | |
| 119 | + avio_seek(pb, 1, SEEK_CUR); /* Read ahead one byte of struct size like read_header */ | |
| 120 | 120 | |
| 121 | 121 | pkt->pts = timestamp; |
| 122 | 122 | pkt->dts = timestamp; |
| @@ -83,10 +83,10 @@ static int mtv_read_header(AVFormatContext *s, AVFormatParameters *ap) · 82 unmodified lines | ||
| 83 | 83 | AVStream *st; |
| 84 | 84 | unsigned int audio_subsegments; |
| 85 | 85 | |
| 86 | − url_fskip(pb, 3); | |
| 86 | + avio_seek(pb, 3, SEEK_CUR); | |
| 87 | 87 | mtv->file_size = avio_rl32(pb); |
| 88 | 88 | mtv->segments = avio_rl32(pb); |
| 89 | − url_fskip(pb, 32); | |
| 89 | + avio_seek(pb, 32, SEEK_CUR); | |
| 90 | 90 | mtv->audio_identifier = avio_rl24(pb); |
| 91 | 91 | mtv->audio_br = avio_rl16(pb); |
| 92 | 92 | mtv->img_colorfmt = avio_rl24(pb); |
| @@ -105,7 +105,7 @@ static int mtv_read_header(AVFormatContext *s, AVFormatParameters *ap) · 12 unmodified lines | ||
| 105 | 105 | mtv->img_height=mtv->img_segment_size / (mtv->img_bpp>>3) |
| 106 | 106 | / mtv->img_width; |
| 107 | 107 | |
| 108 | − url_fskip(pb, 4); | |
| 108 | + avio_seek(pb, 4, SEEK_CUR); | |
| 109 | 109 | audio_subsegments = avio_rl16(pb); |
| 110 | 110 | mtv->full_segment_size = |
| 111 | 111 | audio_subsegments * (MTV_AUDIO_PADDING_SIZE + MTV_ASUBCHUNK_DATA_SIZE) + |
| @@ -164,7 +164,7 @@ static int mtv_read_packet(AVFormatContext *s, AVPacket *pkt) · 52 unmodified lines | ||
| 164 | 164 | |
| 165 | 165 | if((url_ftell(pb) - s->data_offset + mtv->img_segment_size) % mtv->full_segment_size) |
| 166 | 166 | { |
| 167 | − url_fskip(pb, MTV_AUDIO_PADDING_SIZE); | |
| 167 | + avio_seek(pb, MTV_AUDIO_PADDING_SIZE, SEEK_CUR); | |
| 168 | 168 | |
| 169 | 169 | ret = av_get_packet(pb, pkt, MTV_ASUBCHUNK_DATA_SIZE); |
| 170 | 170 | if(ret < 0) |
| @@ -262,7 +262,7 @@ static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv · 261 unmodified lines | ||
| 262 | 262 | av_aes_init(mxf->aesc, s->key, 128, 1); |
| 263 | 263 | } |
| 264 | 264 | // crypto context |
| 265 | − url_fskip(pb, klv_decode_ber_length(pb)); | |
| 265 | + avio_seek(pb, klv_decode_ber_length(pb), SEEK_CUR); | |
| 266 | 266 | // plaintext offset |
| 267 | 267 | klv_decode_ber_length(pb); |
| 268 | 268 | plaintext_size = avio_rb64(pb); |
| @@ -297,7 +297,7 @@ static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv · 28 unmodified lines | ||
| 297 | 297 | &pkt->data[plaintext_size], size >> 4, ivec, 1); |
| 298 | 298 | pkt->size = orig_size; |
| 299 | 299 | pkt->stream_index = index; |
| 300 | − url_fskip(pb, end - url_ftell(pb)); | |
| 300 | + avio_seek(pb, end - url_ftell(pb), SEEK_CUR); | |
| 301 | 301 | return 0; |
| 302 | 302 | } |
| 303 | 303 | |
| @@ -339,7 +339,7 @@ static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt) · 35 unmodified lines | ||
| 339 | 339 | return 0; |
| 340 | 340 | } else |
| 341 | 341 | skip: |
| 342 | − url_fskip(s->pb, klv.length); | |
| 342 | + avio_seek(s->pb, klv.length, SEEK_CUR); | |
| 343 | 343 | } |
| 344 | 344 | return AVERROR_EOF; |
| 345 | 345 | } |
| @@ -397,7 +397,7 @@ static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int siz · 51 unmodified lines | ||
| 397 | 397 | mxf->packages_refs = av_malloc(mxf->packages_count * sizeof(UID)); |
| 398 | 398 | if (!mxf->packages_refs) |
| 399 | 399 | return -1; |
| 400 | − url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ | |
| 400 | + avio_seek(pb, 4, SEEK_CUR); /* useless size of objects, always 16 according to specs */ | |
| 401 | 401 | avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID)); |
| 402 | 402 | break; |
| 403 | 403 | } |
| @@ -416,7 +416,7 @@ static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, U · 12 unmodified lines | ||
| 416 | 416 | break; |
| 417 | 417 | case 0x1101: |
| 418 | 418 | /* UMID, only get last 16 bytes */ |
| 419 | − url_fskip(pb, 16); | |
| 419 | + avio_seek(pb, 16, SEEK_CUR); | |
| 420 | 420 | avio_read(pb, source_clip->source_package_uid, 16); |
| 421 | 421 | break; |
| 422 | 422 | case 0x1102: |
| @@ -437,7 +437,7 @@ static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int si · 14 unmodified lines | ||
| 437 | 437 | package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID)); |
| 438 | 438 | if (!package->tracks_refs) |
| 439 | 439 | return -1; |
| 440 | − url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ | |
| 440 | + avio_seek(pb, 4, SEEK_CUR); /* useless size of objects, always 16 according to specs */ | |
| 441 | 441 | avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID)); |
| 442 | 442 | break; |
| 443 | 443 | } |
| @@ -482,7 +482,7 @@ static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID · 38 unmodified lines | ||
| 482 | 482 | sequence->structural_components_refs = av_malloc(sequence->structural_components_count * sizeof(UID)); |
| 483 | 483 | if (!sequence->structural_components_refs) |
| 484 | 484 | return -1; |
| 485 | − url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ | |
| 485 | + avio_seek(pb, 4, SEEK_CUR); /* useless size of objects, always 16 according to specs */ | |
| 486 | 486 | avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID)); |
| 487 | 487 | break; |
| 488 | 488 | } |
| @@ -500,12 +500,12 @@ static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size · 11 unmodified lines | ||
| 500 | 500 | package->tracks_refs = av_malloc(package->tracks_count * sizeof(UID)); |
| 501 | 501 | if (!package->tracks_refs) |
| 502 | 502 | return -1; |
| 503 | − url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ | |
| 503 | + avio_seek(pb, 4, SEEK_CUR); /* useless size of objects, always 16 according to specs */ | |
| 504 | 504 | avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID)); |
| 505 | 505 | break; |
| 506 | 506 | case 0x4401: |
| 507 | 507 | /* UMID, only get last 16 bytes */ |
| 508 | − url_fskip(pb, 16); | |
| 508 | + avio_seek(pb, 16, SEEK_CUR); | |
| 509 | 509 | avio_read(pb, package->package_uid, 16); |
| 510 | 510 | break; |
| 511 | 511 | case 0x4701: |
| @@ -558,7 +558,7 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int · 46 unmodified lines | ||
| 558 | 558 | descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID)); |
| 559 | 559 | if (!descriptor->sub_descriptors_refs) |
| 560 | 560 | return -1; |
| 561 | − url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */ | |
| 561 | + avio_seek(pb, 4, SEEK_CUR); /* useless size of objects, always 16 according to specs */ | |
| 562 | 562 | avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID)); |
| 563 | 563 | break; |
| 564 | 564 | case 0x3004: |
| @@ -943,7 +943,7 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap) · 378 unmodified lines | ||
| 943 | 943 | } |
| 944 | 944 | } |
| 945 | 945 | if (!metadata->read) |
| 946 | − url_fskip(s->pb, klv.length); | |
| 946 | + avio_seek(s->pb, klv.length, SEEK_CUR); | |
| 947 | 947 | } |
| 948 | 948 | return mxf_parse_structural_metadata(mxf); |
| 949 | 949 | } |
| @@ -73,7 +73,7 @@ static int nc_read_packet(AVFormatContext *s, AVPacket *pkt) · 72 unmodified lines | ||
| 73 | 73 | |
| 74 | 74 | avio_r8(s->pb); |
| 75 | 75 | size = avio_rl16(s->pb); |
| 76 | − url_fskip(s->pb, 9); | |
| 76 | + avio_seek(s->pb, 9, SEEK_CUR); | |
| 77 | 77 | |
| 78 | 78 | if (size == 0) { |
| 79 | 79 | av_log(s, AV_LOG_DEBUG, "Next packet size is zero\n"); |
| @@ -584,7 +584,7 @@ null_chunk_retry: · 583 unmodified lines | ||
| 584 | 584 | ((auxtag >> 16) & 0x0ff), |
| 585 | 585 | ((auxtag >> 24) & 0x0ff), |
| 586 | 586 | auxsize); |
| 587 | − url_fskip(pb, auxsize); | |
| 587 | + avio_seek(pb, auxsize, SEEK_CUR); | |
| 588 | 588 | vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t); /* that's becoming braindead */ |
| 589 | 589 | } |
| 590 | 590 | |
| @@ -757,7 +757,7 @@ static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code){ · 756 unmodified lines | ||
| 757 | 757 | ||(discard >= AVDISCARD_BIDIR && last_IP_pts != AV_NOPTS_VALUE && last_IP_pts > pts) |
| 758 | 758 | || discard >= AVDISCARD_ALL |
| 759 | 759 | || stc->skip_until_key_frame){ |
| 760 | − url_fskip(bc, size); | |
| 760 | + avio_seek(bc, size, SEEK_CUR); | |
| 761 | 761 | return 1; |
| 762 | 762 | } |
| 763 | 763 | |
| @@ -66,7 +66,7 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst, · 65 unmodified lines | ||
| 66 | 66 | switch (frametype) { |
| 67 | 67 | case NUV_EXTRADATA: |
| 68 | 68 | subtype = avio_r8(pb); |
| 69 | − url_fskip(pb, 6); | |
| 69 | + avio_seek(pb, 6, SEEK_CUR); | |
| 70 | 70 | size = PKTSIZE(avio_rl32(pb)); |
| 71 | 71 | if (vst && subtype == 'R') { |
| 72 | 72 | vst->codec->extradata_size = size; |
| @@ -78,7 +78,7 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst, · 5 unmodified lines | ||
| 78 | 78 | } |
| 79 | 79 | break; |
| 80 | 80 | case NUV_MYTHEXT: |
| 81 | − url_fskip(pb, 7); | |
| 81 | + avio_seek(pb, 7, SEEK_CUR); | |
| 82 | 82 | size = PKTSIZE(avio_rl32(pb)); |
| 83 | 83 | if (size != 128 * 4) |
| 84 | 84 | break; |
| @@ -90,7 +90,7 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst, · 5 unmodified lines | ||
| 90 | 90 | if (vst->codec->codec_tag == MKTAG('R', 'J', 'P', 'G')) |
| 91 | 91 | vst->codec->codec_id = CODEC_ID_NUV; |
| 92 | 92 | } else |
| 93 | − url_fskip(pb, 4); | |
| 93 | + avio_seek(pb, 4, SEEK_CUR); | |
| 94 | 94 | |
| 95 | 95 | if (ast) { |
| 96 | 96 | ast->codec->codec_tag = avio_rl32(pb); |
| @@ -102,20 +102,20 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst, · 5 unmodified lines | ||
| 102 | 102 | ast->codec->bits_per_coded_sample); |
| 103 | 103 | ast->need_parsing = AVSTREAM_PARSE_FULL; |
| 104 | 104 | } else |
| 105 | − url_fskip(pb, 4 * 4); | |
| 105 | + avio_seek(pb, 4 * 4, SEEK_CUR); | |
| 106 | 106 | |
| 107 | 107 | size -= 6 * 4; |
| 108 | − url_fskip(pb, size); | |
| 108 | + avio_seek(pb, size, SEEK_CUR); | |
| 109 | 109 | return 1; |
| 110 | 110 | case NUV_SEEKP: |
| 111 | 111 | size = 11; |
| 112 | 112 | break; |
| 113 | 113 | default: |
| 114 | − url_fskip(pb, 7); | |
| 114 | + avio_seek(pb, 7, SEEK_CUR); | |
| 115 | 115 | size = PKTSIZE(avio_rl32(pb)); |
| 116 | 116 | break; |
| 117 | 117 | } |
| 118 | − url_fskip(pb, size); | |
| 118 | + avio_seek(pb, size, SEEK_CUR); | |
| 119 | 119 | } |
| 120 | 120 | return 0; |
| 121 | 121 | } |
| @@ -130,14 +130,14 @@ static int nuv_header(AVFormatContext *s, AVFormatParameters *ap) { · 8 unmodified lines | ||
| 130 | 130 | AVStream *vst = NULL, *ast = NULL; |
| 131 | 131 | avio_read(pb, id_string, 12); |
| 132 | 132 | is_mythtv = !memcmp(id_string, "MythTVVideo", 12); |
| 133 | − url_fskip(pb, 5); // version string | |
| 134 | − url_fskip(pb, 3); // padding | |
| 133 | + avio_seek(pb, 5, SEEK_CUR); // version string | |
| 134 | + avio_seek(pb, 3, SEEK_CUR); // padding | |
| 135 | 135 | width = avio_rl32(pb); |
| 136 | 136 | height = avio_rl32(pb); |
| 137 | 137 | avio_rl32(pb); // unused, "desiredwidth" |
| 138 | 138 | avio_rl32(pb); // unused, "desiredheight" |
| 139 | 139 | avio_r8(pb); // 'P' == progressive, 'I' == interlaced |
| 140 | − url_fskip(pb, 3); // padding | |
| 140 | + avio_seek(pb, 3, SEEK_CUR); // padding | |
| 141 | 141 | aspect = av_int2dbl(avio_rl64(pb)); |
| 142 | 142 | if (aspect > 0.9999 && aspect < 1.0001) |
| 143 | 143 | aspect = 4.0 / 3.0; |
| @@ -206,13 +206,13 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt) { · 62 unmodified lines | ||
| 206 | 206 | switch (frametype) { |
| 207 | 207 | case NUV_EXTRADATA: |
| 208 | 208 | if (!ctx->rtjpg_video) { |
| 209 | − url_fskip(pb, size); | |
| 209 | + avio_seek(pb, size, SEEK_CUR); | |
| 210 | 210 | break; |
| 211 | 211 | } |
| 212 | 212 | case NUV_VIDEO: |
| 213 | 213 | if (ctx->v_id < 0) { |
| 214 | 214 | av_log(s, AV_LOG_ERROR, "Video packet in file without video stream!\n"); |
| 215 | − url_fskip(pb, size); | |
| 215 | + avio_seek(pb, size, SEEK_CUR); | |
| 216 | 216 | break; |
| 217 | 217 | } |
| 218 | 218 | ret = av_new_packet(pkt, copyhdrsize + size); |
| @@ -236,7 +236,7 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt) { · 17 unmodified lines | ||
| 236 | 236 | case NUV_AUDIO: |
| 237 | 237 | if (ctx->a_id < 0) { |
| 238 | 238 | av_log(s, AV_LOG_ERROR, "Audio packet in file without audio stream!\n"); |
| 239 | − url_fskip(pb, size); | |
| 239 | + avio_seek(pb, size, SEEK_CUR); | |
| 240 | 240 | break; |
| 241 | 241 | } |
| 242 | 242 | ret = av_get_packet(pb, pkt, size); |
| @@ -250,7 +250,7 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt) { · 7 unmodified lines | ||
| 250 | 250 | // contains no data, size value is invalid |
| 251 | 251 | break; |
| 252 | 252 | default: |
| 253 | − url_fskip(pb, size); | |
| 253 | + avio_seek(pb, size, SEEK_CUR); | |
| 254 | 254 | break; |
| 255 | 255 | } |
| 256 | 256 | } |
| @@ -122,7 +122,7 @@ recover: · 121 unmodified lines | ||
| 122 | 122 | if (pes_signal != 1) { |
| 123 | 123 | pva_log(s, AV_LOG_WARNING, "expected signaled PES packet, " |
| 124 | 124 | "trying to recover\n"); |
| 125 | − url_fskip(pb, length - 9); | |
| 125 | + avio_seek(pb, length - 9, SEEK_CUR); | |
| 126 | 126 | if (!read_packet) |
| 127 | 127 | return AVERROR(EIO); |
| 128 | 128 | goto recover; |
| @@ -93,7 +93,7 @@ static int qcp_read_header(AVFormatContext *s, AVFormatParameters *ap) · 92 unmodified lines | ||
| 93 | 93 | |
| 94 | 94 | avio_rb32(pb); // "RIFF" |
| 95 | 95 | s->file_size = avio_rl32(pb) + 8; |
| 96 | − url_fskip(pb, 8 + 4 + 1 + 1); // "QLCMfmt " + chunk-size + major-version + minor-version | |
| 96 | + avio_seek(pb, 8 + 4 + 1 + 1, SEEK_CUR); // "QLCMfmt " + chunk-size + major-version + minor-version | |
| 97 | 97 | |
| 98 | 98 | st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
| 99 | 99 | st->codec->channels = 1; |
| @@ -110,13 +110,13 @@ static int qcp_read_header(AVFormatContext *s, AVFormatParameters *ap) · 10 unmodified lines | ||
| 110 | 110 | av_log(s, AV_LOG_ERROR, "Unknown codec GUID.\n"); |
| 111 | 111 | return AVERROR_INVALIDDATA; |
| 112 | 112 | } |
| 113 | − url_fskip(pb, 2 + 80); // codec-version + codec-name | |
| 113 | + avio_seek(pb, 2 + 80, SEEK_CUR); // codec-version + codec-name | |
| 114 | 114 | st->codec->bit_rate = avio_rl16(pb); |
| 115 | 115 | |
| 116 | 116 | s->packet_size = avio_rl16(pb); |
| 117 | − url_fskip(pb, 2); // block-size | |
| 117 | + avio_seek(pb, 2, SEEK_CUR); // block-size | |
| 118 | 118 | st->codec->sample_rate = avio_rl16(pb); |
| 119 | − url_fskip(pb, 2); // sample-size | |
| 119 | + avio_seek(pb, 2, SEEK_CUR); // sample-size | |
| 120 | 120 | |
| 121 | 121 | memset(c->rates_per_mode, -1, sizeof(c->rates_per_mode)); |
| 122 | 122 | nb_rates = avio_rl32(pb); |
| @@ -129,7 +129,7 @@ static int qcp_read_header(AVFormatContext *s, AVFormatParameters *ap) · 6 unmodified lines | ||
| 129 | 129 | } else |
| 130 | 130 | c->rates_per_mode[mode] = size; |
| 131 | 131 | } |
| 132 | − url_fskip(pb, 16 - 2*nb_rates + 20); // empty entries of rate-map-table + reserved | |
| 132 | + avio_seek(pb, 16 - 2*nb_rates + 20, SEEK_CUR); // empty entries of rate-map-table + reserved | |
| 133 | 133 | |
| 134 | 134 | return 0; |
| 135 | 135 | } |
| @@ -174,14 +174,14 @@ static int qcp_read_packet(AVFormatContext *s, AVPacket *pkt) · 38 unmodified lines | ||
| 174 | 174 | case MKTAG('v', 'r', 'a', 't'): |
| 175 | 175 | if (avio_rl32(pb)) // var-rate-flag |
| 176 | 176 | s->packet_size = 0; |
| 177 | − url_fskip(pb, 4); // size-in-packets | |
| 177 | + avio_seek(pb, 4, SEEK_CUR); // size-in-packets | |
| 178 | 178 | break; |
| 179 | 179 | case MKTAG('d', 'a', 't', 'a'): |
| 180 | 180 | c->data_size = chunk_size; |
| 181 | 181 | break; |
| 182 | 182 | |
| 183 | 183 | default: |
| 184 | − url_fskip(pb, chunk_size); | |
| 184 | + avio_seek(pb, chunk_size, SEEK_CUR); | |
| 185 | 185 | } |
| 186 | 186 | } |
| 187 | 187 | return AVERROR_EOF; |
| @@ -72,7 +72,7 @@ static int r3d_read_red1(AVFormatContext *s) · 71 unmodified lines | ||
| 72 | 72 | tmp = avio_rb32(s->pb); // filenum |
| 73 | 73 | av_dlog(s, "filenum %d\n", tmp); |
| 74 | 74 | |
| 75 | − url_fskip(s->pb, 32); // unknown | |
| 75 | + avio_seek(s->pb, 32, SEEK_CUR); // unknown | |
| 76 | 76 | |
| 77 | 77 | st->codec->width = avio_rb32(s->pb); |
| 78 | 78 | st->codec->height = avio_rb32(s->pb); |
| @@ -152,7 +152,7 @@ static void r3d_read_reos(AVFormatContext *s) · 73 unmodified lines | ||
| 152 | 152 | tmp = avio_rb32(s->pb); |
| 153 | 153 | av_dlog(s, "num audio chunks %d\n", tmp); |
| 154 | 154 | |
| 155 | − url_fskip(s->pb, 6*4); | |
| 155 | + avio_seek(s->pb, 6*4, SEEK_CUR); | |
| 156 | 156 | } |
| 157 | 157 | |
| 158 | 158 | static int r3d_read_header(AVFormatContext *s, AVFormatParameters *ap) |
| @@ -332,7 +332,7 @@ static int r3d_read_packet(AVFormatContext *s, AVPacket *pkt) · 173 unmodified lines | ||
| 332 | 332 | break; |
| 333 | 333 | default: |
| 334 | 334 | skip: |
| 335 | − url_fskip(s->pb, atom.size-8); | |
| 335 | + avio_seek(s->pb, atom.size-8, SEEK_CUR); | |
| 336 | 336 | } |
| 337 | 337 | } |
| 338 | 338 | return err; |
| @@ -161,16 +161,16 @@ rdt_load_mdpr (PayloadContext *rdt, AVStream *st, int rule_nr) · 160 unmodified lines | ||
| 161 | 161 | num = avio_rb16(&pb); |
| 162 | 162 | if (rule_nr < 0 || rule_nr >= num) |
| 163 | 163 | return -1; |
| 164 | − url_fskip(&pb, rule_nr * 2); | |
| 164 | + avio_seek(&pb, rule_nr * 2, SEEK_CUR); | |
| 165 | 165 | chunk_nr = avio_rb16(&pb); |
| 166 | − url_fskip(&pb, (num - 1 - rule_nr) * 2); | |
| 166 | + avio_seek(&pb, (num - 1 - rule_nr) * 2, SEEK_CUR); | |
| 167 | 167 | |
| 168 | 168 | /* read MDPR chunks */ |
| 169 | 169 | num = avio_rb16(&pb); |
| 170 | 170 | if (chunk_nr >= num) |
| 171 | 171 | return -1; |
| 172 | 172 | while (chunk_nr--) |
| 173 | − url_fskip(&pb, avio_rb32(&pb)); | |
| 173 | + avio_seek(&pb, avio_rb32(&pb), SEEK_CUR); | |
| 174 | 174 | size = avio_rb32(&pb); |
| 175 | 175 | } else { |
| 176 | 176 | size = rdt->mlti_data_size; |
| @@ -501,7 +501,7 @@ void ff_get_wav_header(AVIOContext *pb, AVCodecContext *codec, int size) · 500 unmodified lines | ||
| 501 | 501 | codec->bits_per_coded_sample = avio_rl16(pb); |
| 502 | 502 | codec->channel_layout = avio_rl32(pb); /* dwChannelMask */ |
| 503 | 503 | id = avio_rl32(pb); /* 4 first bytes of GUID */ |
| 504 | − url_fskip(pb, 12); /* skip end of GUID */ | |
| 504 | + avio_seek(pb, 12, SEEK_CUR); /* skip end of GUID */ | |
| 505 | 505 | cbSize -= 22; |
| 506 | 506 | size -= 22; |
| 507 | 507 | } |
| @@ -514,7 +514,7 @@ void ff_get_wav_header(AVIOContext *pb, AVCodecContext *codec, int size) · 6 unmodified lines | ||
| 514 | 514 | |
| 515 | 515 | /* It is possible for the chunk to contain garbage at the end */ |
| 516 | 516 | if (size > 0) |
| 517 | − url_fskip(pb, size); | |
| 517 | + avio_seek(pb, size, SEEK_CUR); | |
| 518 | 518 | } |
| 519 | 519 | codec->codec_id = ff_wav_codec_get_id(id, codec->bits_per_coded_sample); |
| 520 | 520 | if (codec->codec_id == CODEC_ID_AAC_LATM) { |
| @@ -95,7 +95,7 @@ static av_cold int rl2_read_header(AVFormatContext *s, · 94 unmodified lines | ||
| 95 | 95 | int i; |
| 96 | 96 | int ret = 0; |
| 97 | 97 | |
| 98 | − url_fskip(pb,4); /* skip FORM tag */ | |
| 98 | + avio_seek(pb,4, SEEK_CUR); /* skip FORM tag */ | |
| 99 | 99 | back_size = avio_rl32(pb); /**< get size of the background frame */ |
| 100 | 100 | signature = avio_rb32(pb); |
| 101 | 101 | data_size = avio_rb32(pb); |
| @@ -132,7 +132,7 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb, · 131 unmodified lines | ||
| 132 | 132 | if (version == 3) { |
| 133 | 133 | int header_size = avio_rb16(pb); |
| 134 | 134 | int64_t startpos = url_ftell(pb); |
| 135 | − url_fskip(pb, 14); | |
| 135 | + avio_seek(pb, 14, SEEK_CUR); | |
| 136 | 136 | rm_read_metadata(s, 0); |
| 137 | 137 | if ((startpos + header_size) >= url_ftell(pb) + 2) { |
| 138 | 138 | // fourcc (should always be "lpcJ") |
| @@ -141,7 +141,7 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb, · 2 unmodified lines | ||
| 141 | 141 | } |
| 142 | 142 | // Skip extra header crap (this should never happen) |
| 143 | 143 | if ((startpos + header_size) > url_ftell(pb)) |
| 144 | − url_fskip(pb, header_size + startpos - url_ftell(pb)); | |
| 144 | + avio_seek(pb, header_size + startpos - url_ftell(pb), SEEK_CUR); | |
| 145 | 145 | st->codec->sample_rate = 8000; |
| 146 | 146 | st->codec->channels = 1; |
| 147 | 147 | st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
| @@ -150,7 +150,7 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb, · 2 unmodified lines | ||
| 150 | 150 | int flavor, sub_packet_h, coded_framesize, sub_packet_size; |
| 151 | 151 | int codecdata_length; |
| 152 | 152 | /* old version (4) */ |
| 153 | − url_fskip(pb, 2); /* unused */ | |
| 153 | + avio_seek(pb, 2, SEEK_CUR); /* unused */ | |
| 154 | 154 | avio_rb32(pb); /* .ra4 */ |
| 155 | 155 | avio_rb32(pb); /* data size */ |
| 156 | 156 | avio_rb16(pb); /* version2 */ |
| @@ -321,7 +321,7 @@ ff_rm_read_mdpr_codecdata (AVFormatContext *s, AVIOContext *pb, · 164 unmodified lines | ||
| 321 | 321 | skip: |
| 322 | 322 | /* skip codec info */ |
| 323 | 323 | size = url_ftell(pb) - codec_pos; |
| 324 | − url_fskip(pb, codec_data_size - size); | |
| 324 | + avio_seek(pb, codec_data_size - size, SEEK_CUR); | |
| 325 | 325 | |
| 326 | 326 | return 0; |
| 327 | 327 | } |
| @@ -340,7 +340,7 @@ static int rm_read_index(AVFormatContext *s) · 12 unmodified lines | ||
| 340 | 340 | size = avio_rb32(pb); |
| 341 | 341 | if (size < 20) |
| 342 | 342 | return -1; |
| 343 | − url_fskip(pb, 2); | |
| 343 | + avio_seek(pb, 2, SEEK_CUR); | |
| 344 | 344 | n_pkts = avio_rb32(pb); |
| 345 | 345 | str_id = avio_rb16(pb); |
| 346 | 346 | next_off = avio_rb32(pb); |
| @@ -353,10 +353,10 @@ static int rm_read_index(AVFormatContext *s) · 6 unmodified lines | ||
| 353 | 353 | goto skip; |
| 354 | 354 | |
| 355 | 355 | for (n = 0; n < n_pkts; n++) { |
| 356 | − url_fskip(pb, 2); | |
| 356 | + avio_seek(pb, 2, SEEK_CUR); | |
| 357 | 357 | pts = avio_rb32(pb); |
| 358 | 358 | pos = avio_rb32(pb); |
| 359 | − url_fskip(pb, 4); /* packet no. */ | |
| 359 | + avio_seek(pb, 4, SEEK_CUR); /* packet no. */ | |
| 360 | 360 | |
| 361 | 361 | av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME); |
| 362 | 362 | } |
| @@ -469,7 +469,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap) · 106 unmodified lines | ||
| 469 | 469 | goto header_end; |
| 470 | 470 | default: |
| 471 | 471 | /* unknown tag: skip it */ |
| 472 | − url_fskip(pb, tag_size - 10); | |
| 472 | + avio_seek(pb, tag_size - 10, SEEK_CUR); | |
| 473 | 473 | break; |
| 474 | 474 | } |
| 475 | 475 | } |
| @@ -529,7 +529,7 @@ static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_ · 53 unmodified lines | ||
| 529 | 529 | if(state == MKBETAG('I', 'N', 'D', 'X')){ |
| 530 | 530 | int n_pkts, expected_len; |
| 531 | 531 | len = avio_rb32(pb); |
| 532 | − url_fskip(pb, 2); | |
| 532 | + avio_seek(pb, 2, SEEK_CUR); | |
| 533 | 533 | n_pkts = avio_rb32(pb); |
| 534 | 534 | expected_len = 20 + n_pkts * 14; |
| 535 | 535 | if (len == 20) |
| @@ -566,7 +566,7 @@ static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_ · 30 unmodified lines | ||
| 566 | 566 | if (i == s->nb_streams) { |
| 567 | 567 | skip: |
| 568 | 568 | /* skip packet if unknown number */ |
| 569 | − url_fskip(pb, len); | |
| 569 | + avio_seek(pb, len, SEEK_CUR); | |
| 570 | 570 | rm->remaining_len = 0; |
| 571 | 571 | continue; |
| 572 | 572 | } |
| @@ -929,7 +929,7 @@ static int64_t rm_read_dts(AVFormatContext *s, int stream_index, · 356 unmodified lines | ||
| 929 | 929 | break; |
| 930 | 930 | } |
| 931 | 931 | |
| 932 | − url_fskip(s->pb, len); | |
| 932 | + avio_seek(s->pb, len, SEEK_CUR); | |
| 933 | 933 | } |
| 934 | 934 | *ppos = pos; |
| 935 | 935 | return dts; |
| @@ -187,11 +187,11 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf, · 186 unmodified lines | ||
| 187 | 187 | flags |= RTP_FLAG_KEY; |
| 188 | 188 | len_off = avio_rb24(pb); |
| 189 | 189 | if (mflags & 0x20) /**< relative timestamp */ |
| 190 | − url_fskip(pb, 4); | |
| 190 | + avio_seek(pb, 4, SEEK_CUR); | |
| 191 | 191 | if (mflags & 0x10) /**< has duration */ |
| 192 | − url_fskip(pb, 4); | |
| 192 | + avio_seek(pb, 4, SEEK_CUR); | |
| 193 | 193 | if (mflags & 0x8) /**< has location ID */ |
| 194 | − url_fskip(pb, 4); | |
| 194 | + avio_seek(pb, 4, SEEK_CUR); | |
| 195 | 195 | off = url_ftell(pb); |
| 196 | 196 | |
| 197 | 197 | if (!(mflags & 0x40)) { |
| @@ -214,7 +214,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf, · 16 unmodified lines | ||
| 214 | 214 | return AVERROR(EIO); |
| 215 | 215 | |
| 216 | 216 | avio_write(asf->pktbuf, buf + off, len - off); |
| 217 | − url_fskip(pb, len - off); | |
| 217 | + avio_seek(pb, len - off, SEEK_CUR); | |
| 218 | 218 | if (!(flags & RTP_FLAG_MARKER)) |
| 219 | 219 | return -1; |
| 220 | 220 | out_len = url_close_dyn_buf(asf->pktbuf, &asf->buf); |
| @@ -234,7 +234,7 @@ static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf, · 13 unmodified lines | ||
| 234 | 234 | asf->buf = av_realloc(asf->buf, out_len); |
| 235 | 235 | memcpy(asf->buf + prev_len, buf + off, |
| 236 | 236 | FFMIN(cur_len, len - off)); |
| 237 | − url_fskip(pb, cur_len); | |
| 237 | + avio_seek(pb, cur_len, SEEK_CUR); | |
| 238 | 238 | } |
| 239 | 239 | } |
| 240 | 240 | |
| @@ -149,13 +149,13 @@ static int qt_rtp_parse_packet(AVFormatContext *s, PayloadContext *qt, · 148 unmodified lines | ||
| 149 | 149 | break; |
| 150 | 150 | } |
| 151 | 151 | default: |
| 152 | − url_fskip(&pb, tlv_len); | |
| 152 | + avio_seek(&pb, tlv_len, SEEK_CUR); | |
| 153 | 153 | break; |
| 154 | 154 | } |
| 155 | 155 | } |
| 156 | 156 | |
| 157 | 157 | /* 32-bit alignment */ |
| 158 | − url_fskip(&pb, ((url_ftell(&pb) + 3) & ~3) - url_ftell(&pb)); | |
| 158 | + avio_seek(&pb, ((url_ftell(&pb) + 3) & ~3) - url_ftell(&pb), SEEK_CUR); | |
| 159 | 159 | } else |
| 160 | 160 | avio_seek(&pb, 4, SEEK_SET); |
| 161 | 161 | |
| @@ -51,14 +51,14 @@ int ff_sauce_read(AVFormatContext *avctx, uint64_t *fsize, int *got_width, int g · 50 unmodified lines | ||
| 51 | 51 | GET_SAUCE_META("artist", 20) |
| 52 | 52 | GET_SAUCE_META("publisher", 20) |
| 53 | 53 | GET_SAUCE_META("date", 8) |
| 54 | − url_fskip(pb, 4); | |
| 54 | + avio_seek(pb, 4, SEEK_CUR); | |
| 55 | 55 | datatype = avio_r8(pb); |
| 56 | 56 | filetype = avio_r8(pb); |
| 57 | 57 | t1 = avio_rl16(pb); |
| 58 | 58 | t2 = avio_rl16(pb); |
| 59 | 59 | nb_comments = avio_r8(pb); |
| 60 | 60 | flags = avio_r8(pb); |
| 61 | − url_fskip(pb, 4); | |
| 61 | + avio_seek(pb, 4, SEEK_CUR); | |
| 62 | 62 | GET_SAUCE_META("encoder", 22); |
| 63 | 63 | |
| 64 | 64 | if (got_width && datatype && filetype) { |
| @@ -103,7 +103,7 @@ static int siff_parse_vbv1(AVFormatContext *s, SIFFContext *c, AVIOContext *pb) · 102 unmodified lines | ||
| 103 | 103 | } |
| 104 | 104 | width = avio_rl16(pb); |
| 105 | 105 | height = avio_rl16(pb); |
| 106 | − url_fskip(pb, 4); | |
| 106 | + avio_seek(pb, 4, SEEK_CUR); | |
| 107 | 107 | c->frames = avio_rl16(pb); |
| 108 | 108 | if(!c->frames){ |
| 109 | 109 | av_log(s, AV_LOG_ERROR, "File contains no frames ???\n"); |
| @@ -113,7 +113,7 @@ static int siff_parse_vbv1(AVFormatContext *s, SIFFContext *c, AVIOContext *pb) · 3 unmodified lines | ||
| 113 | 113 | c->rate = avio_rl16(pb); |
| 114 | 114 | c->block_align = c->rate * (c->bits >> 3); |
| 115 | 115 | |
| 116 | − url_fskip(pb, 16); //zeroes | |
| 116 | + avio_seek(pb, 16, SEEK_CUR); //zeroes | |
| 117 | 117 | |
| 118 | 118 | st = av_new_stream(s, 0); |
| 119 | 119 | if (!st) |
| @@ -145,7 +145,7 @@ static int siff_parse_soun(AVFormatContext *s, SIFFContext *c, AVIOContext *pb) · 25 unmodified lines | ||
| 145 | 145 | av_log(s, AV_LOG_ERROR, "Header chunk size is incorrect\n"); |
| 146 | 146 | return -1; |
| 147 | 147 | } |
| 148 | − url_fskip(pb, 4); //unknown value | |
| 148 | + avio_seek(pb, 4, SEEK_CUR); //unknown value | |
| 149 | 149 | c->rate = avio_rl16(pb); |
| 150 | 150 | c->bits = avio_rl16(pb); |
| 151 | 151 | c->block_align = c->rate * (c->bits >> 3); |
| @@ -160,7 +160,7 @@ static int siff_read_header(AVFormatContext *s, AVFormatParameters *ap) · 8 unmodified lines | ||
| 160 | 160 | |
| 161 | 161 | if (avio_rl32(pb) != TAG_SIFF) |
| 162 | 162 | return -1; |
| 163 | − url_fskip(pb, 4); //ignore size | |
| 163 | + avio_seek(pb, 4, SEEK_CUR); //ignore size | |
| 164 | 164 | tag = avio_rl32(pb); |
| 165 | 165 | |
| 166 | 166 | if (tag != TAG_VBV1 && tag != TAG_SOUN){ |
| @@ -176,7 +176,7 @@ static int siff_read_header(AVFormatContext *s, AVFormatParameters *ap) · 9 unmodified lines | ||
| 176 | 176 | av_log(s, AV_LOG_ERROR, "'BODY' chunk is missing\n"); |
| 177 | 177 | return -1; |
| 178 | 178 | } |
| 179 | − url_fskip(pb, 4); //ignore size | |
| 179 | + avio_seek(pb, 4, SEEK_CUR); //ignore size | |
| 180 | 180 | |
| 181 | 181 | return 0; |
| 182 | 182 | } |
| @@ -58,14 +58,14 @@ static int sox_read_header(AVFormatContext *s, · 57 unmodified lines | ||
| 58 | 58 | if (avio_rl32(pb) == SOX_TAG) { |
| 59 | 59 | st->codec->codec_id = CODEC_ID_PCM_S32LE; |
| 60 | 60 | header_size = avio_rl32(pb); |
| 61 | − url_fskip(pb, 8); /* sample count */ | |
| 61 | + avio_seek(pb, 8, SEEK_CUR); /* sample count */ | |
| 62 | 62 | sample_rate = av_int2dbl(avio_rl64(pb)); |
| 63 | 63 | st->codec->channels = avio_rl32(pb); |
| 64 | 64 | comment_size = avio_rl32(pb); |
| 65 | 65 | } else { |
| 66 | 66 | st->codec->codec_id = CODEC_ID_PCM_S32BE; |
| 67 | 67 | header_size = avio_rb32(pb); |
| 68 | − url_fskip(pb, 8); /* sample count */ | |
| 68 | + avio_seek(pb, 8, SEEK_CUR); /* sample count */ | |
| 69 | 69 | sample_rate = av_int2dbl(avio_rb64(pb)); |
| 70 | 70 | st->codec->channels = avio_rb32(pb); |
| 71 | 71 | comment_size = avio_rb32(pb); |
| @@ -105,7 +105,7 @@ static int sox_read_header(AVFormatContext *s, · 33 unmodified lines | ||
| 105 | 105 | AV_METADATA_DONT_STRDUP_VAL); |
| 106 | 106 | } |
| 107 | 107 | |
| 108 | − url_fskip(pb, header_size - SOX_FIXED_HDR - comment_size); | |
| 108 | + avio_seek(pb, header_size - SOX_FIXED_HDR - comment_size, SEEK_CUR); | |
| 109 | 109 | |
| 110 | 110 | st->codec->sample_rate = sample_rate; |
| 111 | 111 | st->codec->bits_per_coded_sample = 32; |
| @@ -201,7 +201,7 @@ static int spdif_read_packet(AVFormatContext *s, AVPacket *pkt) · 200 unmodified lines | ||
| 201 | 201 | } |
| 202 | 202 | |
| 203 | 203 | /* skip over the padding to the beginning of the next frame */ |
| 204 | − url_fskip(pb, offset - pkt->size - BURST_HEADER_SIZE); | |
| 204 | + avio_seek(pb, offset - pkt->size - BURST_HEADER_SIZE, SEEK_CUR); | |
| 205 | 205 | |
| 206 | 206 | if (!s->nb_streams) { |
| 207 | 207 | /* first packet, create a stream */ |
| @@ -70,7 +70,7 @@ static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap) · 69 unmodified lines | ||
| 70 | 70 | /* skip rectangle size */ |
| 71 | 71 | nbits = avio_r8(pb) >> 3; |
| 72 | 72 | len = (4 * nbits - 3 + 7) / 8; |
| 73 | − url_fskip(pb, len); | |
| 73 | + avio_seek(pb, len, SEEK_CUR); | |
| 74 | 74 | swf->frame_rate = avio_rl16(pb); /* 8.8 fixed */ |
| 75 | 75 | avio_rl16(pb); /* frame count */ |
| 76 | 76 | |
| @@ -159,7 +159,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt) · 82 unmodified lines | ||
| 159 | 159 | st = s->streams[i]; |
| 160 | 160 | if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->id == -1) { |
| 161 | 161 | if (st->codec->codec_id == CODEC_ID_MP3) { |
| 162 | − url_fskip(pb, 4); | |
| 162 | + avio_seek(pb, 4, SEEK_CUR); | |
| 163 | 163 | av_get_packet(pb, pkt, len-4); |
| 164 | 164 | } else { // ADPCM, PCM |
| 165 | 165 | av_get_packet(pb, pkt, len); |
| @@ -202,7 +202,7 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt) · 36 unmodified lines | ||
| 202 | 202 | return pkt->size; |
| 203 | 203 | } |
| 204 | 204 | skip: |
| 205 | − url_fskip(pb, len); | |
| 205 | + avio_seek(pb, len, SEEK_CUR); | |
| 206 | 206 | } |
| 207 | 207 | return 0; |
| 208 | 208 | } |
| @@ -152,7 +152,7 @@ static int tmv_read_packet(AVFormatContext *s, AVPacket *pkt) · 151 unmodified lines | ||
| 152 | 152 | ret = av_get_packet(pb, pkt, pkt_size); |
| 153 | 153 | |
| 154 | 154 | if (tmv->stream_index) |
| 155 | − url_fskip(pb, tmv->padding); | |
| 155 | + avio_seek(pb, tmv->padding, SEEK_CUR); | |
| 156 | 156 | |
| 157 | 157 | pkt->stream_index = tmv->stream_index; |
| 158 | 158 | tmv->stream_index ^= 1; |
| @@ -50,7 +50,7 @@ static int tta_read_header(AVFormatContext *s, AVFormatParameters *ap) · 49 unmodified lines | ||
| 50 | 50 | if (avio_rl32(s->pb) != AV_RL32("TTA1")) |
| 51 | 51 | return -1; // not tta file |
| 52 | 52 | |
| 53 | − url_fskip(s->pb, 2); // FIXME: flags | |
| 53 | + avio_seek(s->pb, 2, SEEK_CUR); // FIXME: flags | |
| 54 | 54 | channels = avio_rl16(s->pb); |
| 55 | 55 | bps = avio_rl16(s->pb); |
| 56 | 56 | samplerate = avio_rl32(s->pb); |
| @@ -65,7 +65,7 @@ static int tta_read_header(AVFormatContext *s, AVFormatParameters *ap) · 8 unmodified lines | ||
| 65 | 65 | return -1; |
| 66 | 66 | } |
| 67 | 67 | |
| 68 | − url_fskip(s->pb, 4); // header crc | |
| 68 | + avio_seek(s->pb, 4, SEEK_CUR); // header crc | |
| 69 | 69 | |
| 70 | 70 | framelen = samplerate*256/245; |
| 71 | 71 | c->totalframes = datalen / framelen + ((datalen % framelen) ? 1 : 0); |
| @@ -91,7 +91,7 @@ static int tta_read_header(AVFormatContext *s, AVFormatParameters *ap) · 19 unmodified lines | ||
| 91 | 91 | av_add_index_entry(st, framepos, i*framelen, size, 0, AVINDEX_KEYFRAME); |
| 92 | 92 | framepos += size; |
| 93 | 93 | } |
| 94 | − url_fskip(s->pb, 4); // seektable crc | |
| 94 | + avio_seek(s->pb, 4, SEEK_CUR); // seektable crc | |
| 95 | 95 | |
| 96 | 96 | st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
| 97 | 97 | st->codec->codec_id = CODEC_ID_TTA; |
| @@ -73,7 +73,7 @@ next_chunk: · 72 unmodified lines | ||
| 73 | 73 | if (chunk_size > 100) |
| 74 | 74 | break; |
| 75 | 75 | case TXD_EXTRA: |
| 76 | − url_fskip(s->pb, chunk_size); | |
| 76 | + avio_seek(s->pb, chunk_size, SEEK_CUR); | |
| 77 | 77 | case TXD_FILE: |
| 78 | 78 | case TXD_TEXTURE: |
| 79 | 79 | goto next_chunk; |
| @@ -68,7 +68,7 @@ static int vc1t_read_header(AVFormatContext *s, · 67 unmodified lines | ||
| 68 | 68 | st->codec->width = avio_rl32(pb); |
| 69 | 69 | if(avio_rl32(pb) != 0xC) |
| 70 | 70 | return -1; |
| 71 | − url_fskip(pb, 8); | |
| 71 | + avio_seek(pb, 8, SEEK_CUR); | |
| 72 | 72 | fps = avio_rl32(pb); |
| 73 | 73 | if(fps == 0xFFFFFFFF) |
| 74 | 74 | av_set_pts_info(st, 32, 1, 1000); |
| @@ -45,13 +45,13 @@ static int voc_read_header(AVFormatContext *s, AVFormatParameters *ap) · 44 unmodified lines | ||
| 45 | 45 | int header_size; |
| 46 | 46 | AVStream *st; |
| 47 | 47 | |
| 48 | − url_fskip(pb, 20); | |
| 48 | + avio_seek(pb, 20, SEEK_CUR); | |
| 49 | 49 | header_size = avio_rl16(pb) - 22; |
| 50 | 50 | if (header_size != 4) { |
| 51 | 51 | av_log(s, AV_LOG_ERROR, "unknown header size: %d\n", header_size); |
| 52 | 52 | return AVERROR(ENOSYS); |
| 53 | 53 | } |
| 54 | − url_fskip(pb, header_size); | |
| 54 | + avio_seek(pb, header_size, SEEK_CUR); | |
| 55 | 55 | st = av_new_stream(s, 0); |
| 56 | 56 | if (!st) |
| 57 | 57 | return AVERROR(ENOMEM); |
| @@ -114,13 +114,13 @@ voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size) · 56 unmodified lines | ||
| 114 | 114 | dec->bits_per_coded_sample = avio_r8(pb); |
| 115 | 115 | dec->channels = avio_r8(pb); |
| 116 | 116 | tmp_codec = avio_rl16(pb); |
| 117 | − url_fskip(pb, 4); | |
| 117 | + avio_seek(pb, 4, SEEK_CUR); | |
| 118 | 118 | voc->remaining_size -= 12; |
| 119 | 119 | max_size -= 12; |
| 120 | 120 | break; |
| 121 | 121 | |
| 122 | 122 | default: |
| 123 | − url_fskip(pb, voc->remaining_size); | |
| 123 | + avio_seek(pb, voc->remaining_size, SEEK_CUR); | |
| 124 | 124 | max_size -= voc->remaining_size; |
| 125 | 125 | voc->remaining_size = 0; |
| 126 | 126 | break; |
| @@ -72,7 +72,7 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap) · 71 unmodified lines | ||
| 72 | 72 | if (!st) |
| 73 | 73 | return AVERROR(ENOMEM); |
| 74 | 74 | |
| 75 | − url_fskip(s->pb, 12); | |
| 75 | + avio_seek(s->pb, 12, SEEK_CUR); | |
| 76 | 76 | |
| 77 | 77 | header_size = avio_rb32(s->pb); |
| 78 | 78 | |
| @@ -101,7 +101,7 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap) · 22 unmodified lines | ||
| 101 | 101 | st->codec->channels = avio_rb32(s->pb) + 1; |
| 102 | 102 | read_bitrate = avio_rb32(s->pb); |
| 103 | 103 | rate_flag = avio_rb32(s->pb); |
| 104 | − url_fskip(s->pb, len-12); | |
| 104 | + avio_seek(s->pb, len-12, SEEK_CUR); | |
| 105 | 105 | |
| 106 | 106 | st->codec->bit_rate = read_bitrate*1000; |
| 107 | 107 | st->codec->bits_per_coded_sample = 16; |
| @@ -140,7 +140,7 @@ static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap) · 32 unmodified lines | ||
| 140 | 140 | av_log(s, AV_LOG_ERROR, "Unknown chunk: %c%c%c%c\n", |
| 141 | 141 | ((char*)&chunk_tag)[0], ((char*)&chunk_tag)[1], |
| 142 | 142 | ((char*)&chunk_tag)[2], ((char*)&chunk_tag)[3]); |
| 143 | − url_fskip(s->pb, FFMIN(len, header_size)); | |
| 143 | + avio_seek(s->pb, FFMIN(len, header_size), SEEK_CUR); | |
| 144 | 144 | break; |
| 145 | 145 | } |
| 146 | 146 | |
| @@ -217,7 +217,7 @@ static int wav_read_header(AVFormatContext *s, · 216 unmodified lines | ||
| 217 | 217 | avio_rl64(pb); /* RIFF size */ |
| 218 | 218 | data_size = avio_rl64(pb); |
| 219 | 219 | sample_count = avio_rl64(pb); |
| 220 | − url_fskip(pb, size - 16); /* skip rest of ds64 chunk */ | |
| 220 | + avio_seek(pb, size - 16, SEEK_CUR); /* skip rest of ds64 chunk */ | |
| 221 | 221 | } |
| 222 | 222 | |
| 223 | 223 | /* parse fmt header */ |
| @@ -276,7 +276,7 @@ static int64_t find_guid(AVIOContext *pb, const uint8_t guid1[16]) · 52 unmodified lines | ||
| 276 | 276 | return -1; |
| 277 | 277 | if (!memcmp(guid, guid1, 16)) |
| 278 | 278 | return size; |
| 279 | − url_fskip(pb, FFALIGN(size, INT64_C(8)) - 24); | |
| 279 | + avio_seek(pb, FFALIGN(size, INT64_C(8)) - 24, SEEK_CUR); | |
| 280 | 280 | } |
| 281 | 281 | return -1; |
| 282 | 282 | } |
| @@ -410,7 +410,7 @@ static int w64_read_header(AVFormatContext *s, AVFormatParameters *ap) · 127 unmodified lines | ||
| 410 | 410 | |
| 411 | 411 | /* subtract chunk header size - normal wav file doesn't count it */ |
| 412 | 412 | ff_get_wav_header(pb, st->codec, size - 24); |
| 413 | − url_fskip(pb, FFALIGN(size, INT64_C(8)) - size); | |
| 413 | + avio_seek(pb, FFALIGN(size, INT64_C(8)) - size, SEEK_CUR); | |
| 414 | 414 | |
| 415 | 415 | st->need_parsing = AVSTREAM_PARSE_FULL; |
| 416 | 416 | |
| @@ -539,7 +539,7 @@ static void get_tag(AVFormatContext *s, AVIOContext *pb, const char *key, int ty · 538 unmodified lines | ||
| 539 | 539 | } else { |
| 540 | 540 | av_freep(&buf); |
| 541 | 541 | av_log(s, AV_LOG_WARNING, "unsupported metadata entry; key:%s, type:%d, length:0x%x\n", key, type, length); |
| 542 | − url_fskip(pb, length); | |
| 542 | + avio_seek(pb, length, SEEK_CUR); | |
| 543 | 543 | return; |
| 544 | 544 | } |
| 545 | 545 | |
| @@ -582,7 +582,7 @@ static int parse_videoinfoheader2(AVFormatContext *s, AVStream *st) · 36 unmodified lines | ||
| 582 | 582 | WtvContext *wtv = s->priv_data; |
| 583 | 583 | AVIOContext *pb = wtv->pb; |
| 584 | 584 | |
| 585 | − url_fskip(pb, 72); // picture aspect ratio is unreliable | |
| 585 | + avio_seek(pb, 72, SEEK_CUR); // picture aspect ratio is unreliable | |
| 586 | 586 | ff_get_bmp_header(pb, st); |
| 587 | 587 | |
| 588 | 588 | return 72 + 40; |
| @@ -658,17 +658,17 @@ static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, · 69 unmodified lines | ||
| 658 | 658 | |
| 659 | 659 | if (size < 32) { |
| 660 | 660 | av_log(s, AV_LOG_WARNING, "format buffer size underflow\n"); |
| 661 | − url_fskip(pb, size); | |
| 661 | + avio_seek(pb, size, SEEK_CUR); | |
| 662 | 662 | return NULL; |
| 663 | 663 | } |
| 664 | 664 | |
| 665 | − url_fskip(pb, size - 32); | |
| 665 | + avio_seek(pb, size - 32, SEEK_CUR); | |
| 666 | 666 | ff_get_guid(pb, &actual_subtype); |
| 667 | 667 | ff_get_guid(pb, &actual_formattype); |
| 668 | 668 | avio_seek(pb, -size, SEEK_CUR); |
| 669 | 669 | |
| 670 | 670 | st = parse_media_type(s, st, sid, mediatype, actual_subtype, actual_formattype, size - 32); |
| 671 | − url_fskip(pb, 32); | |
| 671 | + avio_seek(pb, 32, SEEK_CUR); | |
| 672 | 672 | return st; |
| 673 | 673 | } else if (!ff_guidcmp(mediatype, mediatype_audio)) { |
| 674 | 674 | st = new_stream(s, st, sid, AVMEDIA_TYPE_AUDIO); |
| @@ -679,7 +679,7 @@ static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, · 4 unmodified lines | ||
| 679 | 679 | } else { |
| 680 | 680 | if (ff_guidcmp(formattype, format_none)) |
| 681 | 681 | av_log(s, AV_LOG_WARNING, "unknown formattype:"PRI_GUID"\n", ARG_GUID(formattype)); |
| 682 | − url_fskip(pb, size); | |
| 682 | + avio_seek(pb, size, SEEK_CUR); | |
| 683 | 683 | } |
| 684 | 684 | |
| 685 | 685 | if (!memcmp(subtype + 4, (const uint8_t[]){MEDIASUBTYPE_BASE_GUID}, 12)) { |
| @@ -701,14 +701,14 @@ static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, · 15 unmodified lines | ||
| 701 | 701 | return NULL; |
| 702 | 702 | if (!ff_guidcmp(formattype, format_videoinfo2)) { |
| 703 | 703 | int consumed = parse_videoinfoheader2(s, st); |
| 704 | − url_fskip(pb, FFMAX(size - consumed, 0)); | |
| 704 | + avio_seek(pb, FFMAX(size - consumed, 0), SEEK_CUR); | |
| 705 | 705 | } else if (!ff_guidcmp(formattype, format_mpeg2_video)) { |
| 706 | 706 | int consumed = parse_videoinfoheader2(s, st); |
| 707 | − url_fskip(pb, FFMAX(size - consumed, 0)); | |
| 707 | + avio_seek(pb, FFMAX(size - consumed, 0), SEEK_CUR); | |
| 708 | 708 | } else { |
| 709 | 709 | if (ff_guidcmp(formattype, format_none)) |
| 710 | 710 | av_log(s, AV_LOG_WARNING, "unknown formattype:"PRI_GUID"\n", ARG_GUID(formattype)); |
| 711 | − url_fskip(pb, size); | |
| 711 | + avio_seek(pb, size, SEEK_CUR); | |
| 712 | 712 | } |
| 713 | 713 | |
| 714 | 714 | if (!memcmp(subtype + 4, (const uint8_t[]){MEDIASUBTYPE_BASE_GUID}, 12)) { |
| @@ -726,7 +726,7 @@ static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, · 11 unmodified lines | ||
| 726 | 726 | return NULL; |
| 727 | 727 | if (ff_guidcmp(formattype, format_none)) |
| 728 | 728 | av_log(s, AV_LOG_WARNING, "unknown formattype:"PRI_GUID"\n", ARG_GUID(formattype)); |
| 729 | − url_fskip(pb, size); | |
| 729 | + avio_seek(pb, size, SEEK_CUR); | |
| 730 | 730 | st->codec->codec_id = CODEC_ID_DVB_SUBTITLE; |
| 731 | 731 | return st; |
| 732 | 732 | } else if (!ff_guidcmp(mediatype, mediatype_mstvcaption) && |
| @@ -736,21 +736,21 @@ static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, · 3 unmodified lines | ||
| 736 | 736 | return NULL; |
| 737 | 737 | if (ff_guidcmp(formattype, format_none)) |
| 738 | 738 | av_log(s, AV_LOG_WARNING, "unknown formattype:"PRI_GUID"\n", ARG_GUID(formattype)); |
| 739 | − url_fskip(pb, size); | |
| 739 | + avio_seek(pb, size, SEEK_CUR); | |
| 740 | 740 | st->codec->codec_id = CODEC_ID_DVB_TELETEXT; |
| 741 | 741 | return st; |
| 742 | 742 | } else if (!ff_guidcmp(mediatype, mediatype_mpeg2_sections) && |
| 743 | 743 | !ff_guidcmp(subtype, mediasubtype_mpeg2_sections)) { |
| 744 | 744 | if (ff_guidcmp(formattype, format_none)) |
| 745 | 745 | av_log(s, AV_LOG_WARNING, "unknown formattype:"PRI_GUID"\n", ARG_GUID(formattype)); |
| 746 | − url_fskip(pb, size); | |
| 746 | + avio_seek(pb, size, SEEK_CUR); | |
| 747 | 747 | return NULL; |
| 748 | 748 | } |
| 749 | 749 | |
| 750 | 750 | av_log(s, AV_LOG_WARNING, "unknown media type, mediatype:"PRI_GUID |
| 751 | 751 | ", subtype:"PRI_GUID", formattype:"PRI_GUID"\n", |
| 752 | 752 | ARG_GUID(mediatype), ARG_GUID(subtype), ARG_GUID(formattype)); |
| 753 | − url_fskip(pb, size); | |
| 753 | + avio_seek(pb, size, SEEK_CUR); | |
| 754 | 754 | return NULL; |
| 755 | 755 | } |
| 756 | 756 | |
| @@ -779,17 +779,17 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 22 unmodified lines | ||
| 779 | 779 | if (len < 32) |
| 780 | 780 | break; |
| 781 | 781 | sid = avio_rl32(pb) & 0x7FFF; |
| 782 | − url_fskip(pb, 8); | |
| 782 | + avio_seek(pb, 8, SEEK_CUR); | |
| 783 | 783 | consumed = 32; |
| 784 | 784 | |
| 785 | 785 | if (!ff_guidcmp(g, stream_guid)) { |
| 786 | 786 | if (ff_find_stream_index(s, sid) < 0) { |
| 787 | 787 | ff_asf_guid mediatype, subtype, formattype; |
| 788 | 788 | int size; |
| 789 | − url_fskip(pb, 28); | |
| 789 | + avio_seek(pb, 28, SEEK_CUR); | |
| 790 | 790 | ff_get_guid(pb, &mediatype); |
| 791 | 791 | ff_get_guid(pb, &subtype); |
| 792 | − url_fskip(pb, 12); | |
| 792 | + avio_seek(pb, 12, SEEK_CUR); | |
| 793 | 793 | ff_get_guid(pb, &formattype); |
| 794 | 794 | size = avio_rl32(pb); |
| 795 | 795 | parse_media_type(s, 0, sid, mediatype, subtype, formattype, size); |
| @@ -800,10 +800,10 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 4 unmodified lines | ||
| 800 | 800 | if (stream_index >= 0 && !((WtvStream*)s->streams[stream_index]->priv_data)->seen_data) { |
| 801 | 801 | ff_asf_guid mediatype, subtype, formattype; |
| 802 | 802 | int size; |
| 803 | − url_fskip(pb, 12); | |
| 803 | + avio_seek(pb, 12, SEEK_CUR); | |
| 804 | 804 | ff_get_guid(pb, &mediatype); |
| 805 | 805 | ff_get_guid(pb, &subtype); |
| 806 | − url_fskip(pb, 12); | |
| 806 | + avio_seek(pb, 12, SEEK_CUR); | |
| 807 | 807 | ff_get_guid(pb, &formattype); |
| 808 | 808 | size = avio_rl32(pb); |
| 809 | 809 | parse_media_type(s, s->streams[stream_index], sid, mediatype, subtype, formattype, size); |
| @@ -822,11 +822,11 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 12 unmodified lines | ||
| 822 | 822 | const uint8_t *pbuf = buf; |
| 823 | 823 | int buf_size; |
| 824 | 824 | |
| 825 | − url_fskip(pb, 8); | |
| 825 | + avio_seek(pb, 8, SEEK_CUR); | |
| 826 | 826 | consumed += 8; |
| 827 | 827 | if (!ff_guidcmp(g, EVENTID_CtxADescriptorSpanningEvent) || |
| 828 | 828 | !ff_guidcmp(g, EVENTID_CSDescriptorSpanningEvent)) { |
| 829 | − url_fskip(pb, 6); | |
| 829 | + avio_seek(pb, 6, SEEK_CUR); | |
| 830 | 830 | consumed += 6; |
| 831 | 831 | } |
| 832 | 832 | |
| @@ -840,7 +840,7 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 7 unmodified lines | ||
| 840 | 840 | if (stream_index >= 0) { |
| 841 | 841 | AVStream *st = s->streams[stream_index]; |
| 842 | 842 | int audio_type; |
| 843 | − url_fskip(pb, 8); | |
| 843 | + avio_seek(pb, 8, SEEK_CUR); | |
| 844 | 844 | audio_type = avio_r8(pb); |
| 845 | 845 | if (audio_type == 2) |
| 846 | 846 | st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; |
| @@ -851,7 +851,7 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 4 unmodified lines | ||
| 851 | 851 | } else if (!ff_guidcmp(g, EVENTID_DVBScramblingControlSpanningEvent)) { |
| 852 | 852 | int stream_index = ff_find_stream_index(s, sid); |
| 853 | 853 | if (stream_index >= 0) { |
| 854 | − url_fskip(pb, 12); | |
| 854 | + avio_seek(pb, 12, SEEK_CUR); | |
| 855 | 855 | if (avio_rl32(pb)) |
| 856 | 856 | av_log(s, AV_LOG_WARNING, "DVB scrambled stream detected (st:%d), decoding will likely fail\n", stream_index); |
| 857 | 857 | consumed += 16; |
| @@ -861,7 +861,7 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 3 unmodified lines | ||
| 861 | 861 | if (stream_index >= 0) { |
| 862 | 862 | AVStream *st = s->streams[stream_index]; |
| 863 | 863 | uint8_t language[4]; |
| 864 | − url_fskip(pb, 12); | |
| 864 | + avio_seek(pb, 12, SEEK_CUR); | |
| 865 | 865 | avio_read(pb, language, 3); |
| 866 | 866 | if (language[0]) { |
| 867 | 867 | language[3] = 0; |
| @@ -874,7 +874,7 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 6 unmodified lines | ||
| 874 | 874 | } else if (!ff_guidcmp(g, timestamp_guid)) { |
| 875 | 875 | int stream_index = ff_find_stream_index(s, sid); |
| 876 | 876 | if (stream_index >= 0) { |
| 877 | − url_fskip(pb, 8); | |
| 877 | + avio_seek(pb, 8, SEEK_CUR); | |
| 878 | 878 | wtv->pts = avio_rl64(pb); |
| 879 | 879 | consumed += 16; |
| 880 | 880 | if (wtv->pts == -1) |
| @@ -885,7 +885,7 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 4 unmodified lines | ||
| 885 | 885 | wtv->epoch = wtv->pts; |
| 886 | 886 | if (mode == SEEK_TO_PTS && wtv->pts >= seekts) { |
| 887 | 887 | #define WTV_PAD8(x) (((x) + 7) & ~7) |
| 888 | − url_fskip(pb, WTV_PAD8(len) - consumed); | |
| 888 | + avio_seek(pb, WTV_PAD8(len) - consumed, SEEK_CUR); | |
| 889 | 889 | return 0; |
| 890 | 890 | } |
| 891 | 891 | } |
| @@ -923,7 +923,7 @@ static int parse_chunks(AVFormatContext *s, int mode, int64_t seekts, int *len_p · 31 unmodified lines | ||
| 923 | 923 | } else |
| 924 | 924 | av_log(s, AV_LOG_WARNING, "unsupported chunk:"PRI_GUID"\n", ARG_GUID(g)); |
| 925 | 925 | |
| 926 | − url_fskip(pb, WTV_PAD8(len) - consumed); | |
| 926 | + avio_seek(pb, WTV_PAD8(len) - consumed, SEEK_CUR); | |
| 927 | 927 | } |
| 928 | 928 | return AVERROR_EOF; |
| 929 | 929 | } |
| @@ -954,13 +954,13 @@ static int read_header(AVFormatContext *s, AVFormatParameters *ap) · 24 unmodified lines | ||
| 954 | 954 | wtv->last_valid_pts = AV_NOPTS_VALUE; |
| 955 | 955 | |
| 956 | 956 | /* read root directory sector */ |
| 957 | − url_fskip(s->pb, 0x30); | |
| 957 | + avio_seek(s->pb, 0x30, SEEK_CUR); | |
| 958 | 958 | root_size = avio_rl32(s->pb); |
| 959 | 959 | if (root_size > sizeof(root)) { |
| 960 | 960 | av_log(s, AV_LOG_ERROR, "root directory size exceeds sector size\n"); |
| 961 | 961 | return AVERROR_INVALIDDATA; |
| 962 | 962 | } |
| 963 | − url_fskip(s->pb, 4); | |
| 963 | + avio_seek(s->pb, 4, SEEK_CUR); | |
| 964 | 964 | root_sector = avio_rl32(s->pb); |
| 965 | 965 | |
| 966 | 966 | avio_seek(s->pb, root_sector << WTV_SECTOR_BITS, SEEK_SET); |
| @@ -1047,7 +1047,7 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt) · 80 unmodified lines | ||
| 1047 | 1047 | return ret; |
| 1048 | 1048 | pkt->stream_index = stream_index; |
| 1049 | 1049 | pkt->pts = wtv->pts; |
| 1050 | − url_fskip(pb, WTV_PAD8(len) - len); | |
| 1050 | + avio_seek(pb, WTV_PAD8(len) - len, SEEK_CUR); | |
| 1051 | 1051 | return 0; |
| 1052 | 1052 | } |
| 1053 | 1053 | |
| @@ -153,7 +153,7 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb, int appen · 152 unmodified lines | ||
| 153 | 153 | chmask = avio_rl32(pb); |
| 154 | 154 | break; |
| 155 | 155 | case 5: |
| 156 | − url_fskip(pb, 1); | |
| 156 | + avio_seek(pb, 1, SEEK_CUR); | |
| 157 | 157 | chan |= (avio_r8(pb) & 0xF) << 8; |
| 158 | 158 | chmask = avio_rl24(pb); |
| 159 | 159 | break; |
| @@ -166,10 +166,10 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb, int appen · 6 unmodified lines | ||
| 166 | 166 | rate = avio_rl24(pb); |
| 167 | 167 | break; |
| 168 | 168 | default: |
| 169 | − url_fskip(pb, size); | |
| 169 | + avio_seek(pb, size, SEEK_CUR); | |
| 170 | 170 | } |
| 171 | 171 | if(id&0x40) |
| 172 | − url_fskip(pb, 1); | |
| 172 | + avio_seek(pb, 1, SEEK_CUR); | |
| 173 | 173 | } |
| 174 | 174 | if(rate == -1){ |
| 175 | 175 | av_log(ctx, AV_LOG_ERROR, "Cannot determine custom sampling rate\n"); |
| @@ -76,9 +76,9 @@ static int xa_read_header(AVFormatContext *s, · 75 unmodified lines | ||
| 76 | 76 | |
| 77 | 77 | st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
| 78 | 78 | st->codec->codec_id = CODEC_ID_ADPCM_EA_MAXIS_XA; |
| 79 | − url_fskip(pb, 4); /* Skip the XA ID */ | |
| 79 | + avio_seek(pb, 4, SEEK_CUR); /* Skip the XA ID */ | |
| 80 | 80 | xa->out_size = avio_rl32(pb); |
| 81 | − url_fskip(pb, 2); /* Skip the tag */ | |
| 81 | + avio_seek(pb, 2, SEEK_CUR); /* Skip the tag */ | |
| 82 | 82 | st->codec->channels = avio_rl16(pb); |
| 83 | 83 | st->codec->sample_rate = avio_rl32(pb); |
| 84 | 84 | /* Value in file is average byte rate*/ |
| @@ -81,7 +81,7 @@ static int yop_read_header(AVFormatContext *s, AVFormatParameters *ap) · 80 unmodified lines | ||
| 81 | 81 | video_dec->codec_type = AVMEDIA_TYPE_VIDEO; |
| 82 | 82 | video_dec->codec_id = CODEC_ID_YOP; |
| 83 | 83 | |
| 84 | − url_fskip(pb, 6); | |
| 84 | + avio_seek(pb, 6, SEEK_CUR); | |
| 85 | 85 | |
| 86 | 86 | frame_rate = avio_r8(pb); |
| 87 | 87 | yop->frame_size = avio_r8(pb) * 2048; |
| @@ -153,7 +153,7 @@ static int yop_read_packet(AVFormatContext *s, AVPacket *pkt) · 65 unmodified lines | ||
| 153 | 153 | // Set position to the start of the frame |
| 154 | 154 | pkt->pos = yop->video_packet.pos; |
| 155 | 155 | |
| 156 | − url_fskip(pb, yop->audio_block_length - ret); | |
| 156 | + avio_seek(pb, yop->audio_block_length - ret, SEEK_CUR); | |
| 157 | 157 | |
| 158 | 158 | ret = avio_read(pb, yop->video_packet.data + yop->palette_size, |
| 159 | 159 | actual_video_data_size); |