LCOV - code coverage report
Current view: top level - src/libavformat/tests - seek.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 67 83 80.7 %
Date: 2017-04-24 03:48:25 Functions: 3 3 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2003 Fabrice Bellard
       3             :  * Copyright (c) 2007 Michael Niedermayer
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #include <stdint.h>
      23             : #include <stdlib.h>
      24             : #include <stdio.h>
      25             : #include <string.h>
      26             : 
      27             : #include "libavutil/common.h"
      28             : #include "libavutil/mathematics.h"
      29             : 
      30             : #include "libavformat/avformat.h"
      31             : 
      32             : static char buffer[20];
      33             : 
      34        5540 : static const char *ret_str(int v)
      35             : {
      36        5540 :     switch (v) {
      37          65 :     case AVERROR_EOF:     return "-EOF";
      38           0 :     case AVERROR(EIO):    return "-EIO";
      39           0 :     case AVERROR(ENOMEM): return "-ENOMEM";
      40         238 :     case AVERROR(EINVAL): return "-EINVAL";
      41             :     default:
      42        5237 :         snprintf(buffer, sizeof(buffer), "%2d", v);
      43        5237 :         return buffer;
      44             :     }
      45             : }
      46             : 
      47        7882 : static void ts_str(char buffer[60], int64_t ts, AVRational base)
      48             : {
      49        7882 :     if (ts == AV_NOPTS_VALUE) {
      50         276 :         strcpy(buffer, " NOPTS   ");
      51         276 :         return;
      52             :     }
      53        7606 :     ts= av_rescale_q(ts, base, (AVRational){1, 1000000});
      54        7606 :     snprintf(buffer, 60, "%c%"PRId64".%06"PRId64"", ts<0 ? '-' : ' ', FFABS(ts)/1000000, FFABS(ts)%1000000);
      55             : }
      56             : 
      57         118 : int main(int argc, char **argv)
      58             : {
      59             :     const char *filename;
      60         118 :     AVFormatContext *ic = avformat_alloc_context();
      61             :     int i, ret, stream_id;
      62             :     int j;
      63             :     int64_t timestamp;
      64         118 :     AVDictionary *format_opts = NULL;
      65         118 :     int64_t seekfirst = AV_NOPTS_VALUE;
      66         118 :     int firstback=0;
      67         118 :     int frame_count = 1;
      68         118 :     int duration = 4;
      69             : 
      70         118 :     ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
      71             : 
      72         120 :     for(i=2; i<argc; i+=2){
      73           2 :         if       (!strcmp(argv[i], "-seekforw")){
      74           0 :             seekfirst = atoi(argv[i+1]);
      75           2 :         } else if(!strcmp(argv[i], "-seekback")){
      76           0 :             seekfirst = atoi(argv[i+1]);
      77           0 :             firstback = 1;
      78           2 :         } else if(!strcmp(argv[i], "-frames")){
      79           0 :             frame_count = atoi(argv[i+1]);
      80           2 :         } else if(!strcmp(argv[i], "-duration")){
      81           0 :             duration = atoi(argv[i+1]);
      82           2 :         } else if(!strcmp(argv[i], "-fastseek")) {
      83           1 :             if (atoi(argv[i+1])) {
      84           1 :                 ic->flags |= AVFMT_FLAG_FAST_SEEK;
      85             :             }
      86           1 :         } else if(argv[i][0] == '-' && argv[i+1]) {
      87           1 :             av_dict_set(&format_opts, argv[i] + 1, argv[i+1], 0);
      88             :         } else {
      89           0 :             argc = 1;
      90             :         }
      91             :     }
      92             : 
      93         118 :     av_dict_set(&format_opts, "channels", "1", 0);
      94         118 :     av_dict_set(&format_opts, "sample_rate", "22050", 0);
      95             : 
      96             :     /* initialize libavcodec, and register all codecs and formats */
      97         118 :     av_register_all();
      98             : 
      99         118 :     if (argc < 2) {
     100           0 :         printf("usage: %s input_file\n"
     101             :                "\n", argv[0]);
     102           0 :         return 1;
     103             :     }
     104             : 
     105         118 :     filename = argv[1];
     106             : 
     107         118 :     ret = avformat_open_input(&ic, filename, NULL, &format_opts);
     108         118 :     av_dict_free(&format_opts);
     109         118 :     if (ret < 0) {
     110           0 :         fprintf(stderr, "cannot open %s\n", filename);
     111           0 :         return 1;
     112             :     }
     113             : 
     114         118 :     ret = avformat_find_stream_info(ic, NULL);
     115         118 :     if (ret < 0) {
     116           0 :         fprintf(stderr, "%s: could not find codec parameters\n", filename);
     117           0 :         return 1;
     118             :     }
     119             : 
     120         118 :     if(seekfirst != AV_NOPTS_VALUE){
     121           0 :         if(firstback)   avformat_seek_file(ic, -1, INT64_MIN, seekfirst, seekfirst, 0);
     122           0 :         else            avformat_seek_file(ic, -1, seekfirst, seekfirst, INT64_MAX, 0);
     123             :     }
     124        3186 :     for(i=0; ; i++){
     125        3186 :         AVPacket pkt = { 0 };
     126        3186 :         AVStream *av_uninit(st);
     127             :         char ts_buf[60];
     128             : 
     129        3186 :         if(ret>=0){
     130        4944 :             for(j=0; j<frame_count; j++) {
     131        2472 :             ret= av_read_frame(ic, &pkt);
     132        2472 :             if(ret>=0){
     133             :                 char dts_buf[60];
     134        2407 :                 st= ic->streams[pkt.stream_index];
     135        2407 :                 ts_str(dts_buf, pkt.dts, st->time_base);
     136        2407 :                 ts_str(ts_buf,  pkt.pts, st->time_base);
     137        2407 :                 printf("ret:%-10s st:%2d flags:%d dts:%s pts:%s pos:%7" PRId64 " size:%6d", ret_str(ret), pkt.stream_index, pkt.flags, dts_buf, ts_buf, pkt.pos, pkt.size);
     138        2407 :                 av_packet_unref(&pkt);
     139             :             } else
     140          65 :                 printf("ret:%s", ret_str(ret)); // necessary to avoid trailing whitespace
     141        2472 :             printf("\n");
     142             :             }
     143             :         }
     144             : 
     145        3186 :         if(i>25) break;
     146             : 
     147        3068 :         stream_id= (i>>1)%(ic->nb_streams+1) - 1;
     148        3068 :         timestamp= (i*19362894167LL) % (duration*AV_TIME_BASE) - AV_TIME_BASE;
     149        3068 :         if(stream_id>=0){
     150        1474 :             st= ic->streams[stream_id];
     151        1474 :             timestamp= av_rescale_q(timestamp, AV_TIME_BASE_Q, st->time_base);
     152             :         }
     153             :         //FIXME fully test the new seek API
     154        3068 :         if(i&1) ret = avformat_seek_file(ic, stream_id, INT64_MIN, timestamp, timestamp, 0);
     155        1534 :         else    ret = avformat_seek_file(ic, stream_id, timestamp, timestamp, INT64_MAX, 0);
     156        3068 :         ts_str(ts_buf, timestamp, stream_id < 0 ? AV_TIME_BASE_Q : st->time_base);
     157        3068 :         printf("ret:%-10s st:%2d flags:%d  ts:%s\n", ret_str(ret), stream_id, i&1, ts_buf);
     158             :     }
     159             : 
     160         118 :     avformat_close_input(&ic);
     161             : 
     162         118 :     return 0;
     163             : }

Generated by: LCOV version 1.13