git.sesse.net Git - ffmpeg/blob - libavformat/ffmdec.c

   1 /*
   2  * FFM (avserver live feed) demuxer
   3  * Copyright (c) 2001 Fabrice Bellard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; 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
  24 #include "libavutil/intreadwrite.h"
  25 #include "libavutil/intfloat.h"
  26 #include "avformat.h"
  27 #include "internal.h"
  28 #include "ffm.h"
  29
  30 static int ffm_is_avail_data(AVFormatContext *s, int size)
  31 {
  32     FFMContext *ffm = s->priv_data;
  33     int64_t pos, avail_size;
  34     int len;
  35
  36     len = ffm->packet_end - ffm->packet_ptr;
  37     if (size <= len)
  38         return 1;
  39     pos = avio_tell(s->pb);
  40     if (!ffm->write_index) {
  41         if (pos == ffm->file_size)
  42             return AVERROR_EOF;
  43         avail_size = ffm->file_size - pos;
  44     } else {
  45     if (pos == ffm->write_index) {
  46         /* exactly at the end of stream */
  47         return AVERROR(EAGAIN);
  48     } else if (pos < ffm->write_index) {
  49         avail_size = ffm->write_index - pos;
  50     } else {
  51         avail_size = (ffm->file_size - pos) + (ffm->write_index - FFM_PACKET_SIZE);
  52     }
  53     }
  54     avail_size = (avail_size / ffm->packet_size) * (ffm->packet_size - FFM_HEADER_SIZE) + len;
  55     if (size <= avail_size)
  56         return 1;
  57     else
  58         return AVERROR(EAGAIN);
  59 }
  60
  61 static int ffm_resync(AVFormatContext *s, int state)
  62 {
  63     av_log(s, AV_LOG_ERROR, "resyncing\n");
  64     while (state != PACKET_ID) {
  65         if (s->pb->eof_reached) {
  66             av_log(s, AV_LOG_ERROR, "cannot find FFM syncword\n");
  67             return -1;
  68         }
  69         state = (state << 8) | avio_r8(s->pb);
  70     }
  71     return 0;
  72 }
  73
  74 /* first is true if we read the frame header */
  75 static int ffm_read_data(AVFormatContext *s,
  76                          uint8_t *buf, int size, int header)
  77 {
  78     FFMContext *ffm = s->priv_data;
  79     AVIOContext *pb = s->pb;
  80     int len, fill_size, size1, frame_offset, id;
  81
  82     size1 = size;
  83     while (size > 0) {
  84     redo:
  85         len = ffm->packet_end - ffm->packet_ptr;
  86         if (len < 0)
  87             return -1;
  88         if (len > size)
  89             len = size;
  90         if (len == 0) {
  91             if (avio_tell(pb) == ffm->file_size)
  92                 avio_seek(pb, ffm->packet_size, SEEK_SET);
  93     retry_read:
  94             id = avio_rb16(pb); /* PACKET_ID */
  95             if (id != PACKET_ID)
  96                 if (ffm_resync(s, id) < 0)
  97                     return -1;
  98             fill_size = avio_rb16(pb);
  99             ffm->dts = avio_rb64(pb);
 100             frame_offset = avio_rb16(pb);
 101             avio_read(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);
 102             ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);
 103             if (ffm->packet_end < ffm->packet || frame_offset < 0)
 104                 return -1;
 105             /* if first packet or resynchronization packet, we must
 106                handle it specifically */
 107             if (ffm->first_packet || (frame_offset & 0x8000)) {
 108                 if (!frame_offset) {
 109                     /* This packet has no frame headers in it */
 110                     if (avio_tell(pb) >= ffm->packet_size * 3) {
 111                         avio_seek(pb, -ffm->packet_size * 2, SEEK_CUR);
 112                         goto retry_read;
 113                     }
 114                     /* This is bad, we cannot find a valid frame header */
 115                     return 0;
 116                 }
 117                 ffm->first_packet = 0;
 118                 if ((frame_offset & 0x7fff) < FFM_HEADER_SIZE)
 119                     return -1;
 120                 ffm->packet_ptr = ffm->packet + (frame_offset & 0x7fff) - FFM_HEADER_SIZE;
 121                 if (!header)
 122                     break;
 123             } else {
 124                 ffm->packet_ptr = ffm->packet;
 125             }
 126             goto redo;
 127         }
 128         memcpy(buf, ffm->packet_ptr, len);
 129         buf += len;
 130         ffm->packet_ptr += len;
 131         size -= len;
 132         header = 0;
 133     }
 134     return size1 - size;
 135 }
 136
 137 /* ensure that acutal seeking happens between FFM_PACKET_SIZE
 138    and file_size - FFM_PACKET_SIZE */
 139 static int64_t ffm_seek1(AVFormatContext *s, int64_t pos1)
 140 {
 141     FFMContext *ffm = s->priv_data;
 142     AVIOContext *pb = s->pb;
 143     int64_t pos;
 144
 145     pos = FFMIN(pos1, ffm->file_size - FFM_PACKET_SIZE);
 146     pos = FFMAX(pos, FFM_PACKET_SIZE);
 147     av_dlog(s, "seek to %"PRIx64" -> %"PRIx64"\n", pos1, pos);
 148     return avio_seek(pb, pos, SEEK_SET);
 149 }
 150
 151 static int64_t get_dts(AVFormatContext *s, int64_t pos)
 152 {
 153     AVIOContext *pb = s->pb;
 154     int64_t dts;
 155
 156     ffm_seek1(s, pos);
 157     avio_skip(pb, 4);
 158     dts = avio_rb64(pb);
 159     av_dlog(s, "dts=%0.6f\n", dts / 1000000.0);
 160     return dts;
 161 }
 162
 163 static void adjust_write_index(AVFormatContext *s)
 164 {
 165     FFMContext *ffm = s->priv_data;
 166     AVIOContext *pb = s->pb;
 167     int64_t pts;
 168     //int64_t orig_write_index = ffm->write_index;
 169     int64_t pos_min, pos_max;
 170     int64_t pts_start;
 171     int64_t ptr = avio_tell(pb);
 172
 173
 174     pos_min = 0;
 175     pos_max = ffm->file_size - 2 * FFM_PACKET_SIZE;
 176
 177     pts_start = get_dts(s, pos_min);
 178
 179     pts = get_dts(s, pos_max);
 180
 181     if (pts - 100000 > pts_start)
 182         goto end;
 183
 184     ffm->write_index = FFM_PACKET_SIZE;
 185
 186     pts_start = get_dts(s, pos_min);
 187
 188     pts = get_dts(s, pos_max);
 189
 190     if (pts - 100000 <= pts_start) {
 191         while (1) {
 192             int64_t newpos;
 193             int64_t newpts;
 194
 195             newpos = ((pos_max + pos_min) / (2 * FFM_PACKET_SIZE)) * FFM_PACKET_SIZE;
 196
 197             if (newpos == pos_min)
 198                 break;
 199
 200             newpts = get_dts(s, newpos);
 201
 202             if (newpts - 100000 <= pts) {
 203                 pos_max = newpos;
 204                 pts = newpts;
 205             } else {
 206                 pos_min = newpos;
 207             }
 208         }
 209         ffm->write_index += pos_max;
 210     }
 211
 212  end:
 213     avio_seek(pb, ptr, SEEK_SET);
 214 }
 215
 216
 217 static int ffm_close(AVFormatContext *s)
 218 {
 219     int i;
 220
 221     for (i = 0; i < s->nb_streams; i++)
 222         av_freep(&s->streams[i]->codec->rc_eq);
 223
 224     return 0;
 225 }
 226
 227
 228 static int ffm_read_header(AVFormatContext *s)
 229 {
 230     FFMContext *ffm = s->priv_data;
 231     AVStream *st;
 232     AVIOContext *pb = s->pb;
 233     AVCodecContext *codec;
 234     int i, nb_streams;
 235     uint32_t tag;
 236
 237     /* header */
 238     tag = avio_rl32(pb);
 239     if (tag != MKTAG('F', 'F', 'M', '1'))
 240         goto fail;
 241     ffm->packet_size = avio_rb32(pb);
 242     if (ffm->packet_size != FFM_PACKET_SIZE)
 243         goto fail;
 244     ffm->write_index = avio_rb64(pb);
 245     /* get also filesize */
 246     if (pb->seekable) {
 247         ffm->file_size = avio_size(pb);
 248         if (ffm->write_index)
 249             adjust_write_index(s);
 250     } else {
 251         ffm->file_size = (UINT64_C(1) << 63) - 1;
 252     }
 253
 254     nb_streams = avio_rb32(pb);
 255     avio_rb32(pb); /* total bitrate */
 256     /* read each stream */
 257     for(i=0;i<nb_streams;i++) {
 258         char rc_eq_buf[128];
 259
 260         st = avformat_new_stream(s, NULL);
 261         if (!st)
 262             goto fail;
 263
 264         avpriv_set_pts_info(st, 64, 1, 1000000);
 265
 266         codec = st->codec;
 267         /* generic info */
 268         codec->codec_id = avio_rb32(pb);
 269         codec->codec_type = avio_r8(pb); /* codec_type */
 270         codec->bit_rate = avio_rb32(pb);
 271         codec->flags = avio_rb32(pb);
 272         codec->flags2 = avio_rb32(pb);
 273         codec->debug = avio_rb32(pb);
 274         /* specific info */
 275         switch(codec->codec_type) {
 276         case AVMEDIA_TYPE_VIDEO:
 277             codec->time_base.num = avio_rb32(pb);
 278             codec->time_base.den = avio_rb32(pb);
 279             codec->width = avio_rb16(pb);
 280             codec->height = avio_rb16(pb);
 281             codec->gop_size = avio_rb16(pb);
 282             codec->pix_fmt = avio_rb32(pb);
 283             codec->qmin = avio_r8(pb);
 284             codec->qmax = avio_r8(pb);
 285             codec->max_qdiff = avio_r8(pb);
 286             codec->qcompress = avio_rb16(pb) / 10000.0;
 287             codec->qblur = avio_rb16(pb) / 10000.0;
 288             codec->bit_rate_tolerance = avio_rb32(pb);
 289             avio_get_str(pb, INT_MAX, rc_eq_buf, sizeof(rc_eq_buf));
 290             codec->rc_eq = av_strdup(rc_eq_buf);
 291             codec->rc_max_rate = avio_rb32(pb);
 292             codec->rc_min_rate = avio_rb32(pb);
 293             codec->rc_buffer_size = avio_rb32(pb);
 294             codec->i_quant_factor = av_int2double(avio_rb64(pb));
 295             codec->b_quant_factor = av_int2double(avio_rb64(pb));
 296             codec->i_quant_offset = av_int2double(avio_rb64(pb));
 297             codec->b_quant_offset = av_int2double(avio_rb64(pb));
 298             codec->dct_algo = avio_rb32(pb);
 299             codec->strict_std_compliance = avio_rb32(pb);
 300             codec->max_b_frames = avio_rb32(pb);
 301             codec->mpeg_quant = avio_rb32(pb);
 302             codec->intra_dc_precision = avio_rb32(pb);
 303             codec->me_method = avio_rb32(pb);
 304             codec->mb_decision = avio_rb32(pb);
 305             codec->nsse_weight = avio_rb32(pb);
 306             codec->frame_skip_cmp = avio_rb32(pb);
 307             codec->rc_buffer_aggressivity = av_int2double(avio_rb64(pb));
 308             codec->codec_tag = avio_rb32(pb);
 309             codec->thread_count = avio_r8(pb);
 310             codec->coder_type = avio_rb32(pb);
 311             codec->me_cmp = avio_rb32(pb);
 312             codec->me_subpel_quality = avio_rb32(pb);
 313             codec->me_range = avio_rb32(pb);
 314             codec->keyint_min = avio_rb32(pb);
 315             codec->scenechange_threshold = avio_rb32(pb);
 316             codec->b_frame_strategy = avio_rb32(pb);
 317             codec->qcompress = av_int2double(avio_rb64(pb));
 318             codec->qblur = av_int2double(avio_rb64(pb));
 319             codec->max_qdiff = avio_rb32(pb);
 320             codec->refs = avio_rb32(pb);
 321             break;
 322         case AVMEDIA_TYPE_AUDIO:
 323             codec->sample_rate = avio_rb32(pb);
 324             codec->channels = avio_rl16(pb);
 325             codec->frame_size = avio_rl16(pb);
 326             break;
 327         default:
 328             goto fail;
 329         }
 330         if (codec->flags & CODEC_FLAG_GLOBAL_HEADER) {
 331             codec->extradata_size = avio_rb32(pb);
 332             codec->extradata = av_malloc(codec->extradata_size);
 333             if (!codec->extradata)
 334                 return AVERROR(ENOMEM);
 335             avio_read(pb, codec->extradata, codec->extradata_size);
 336         }
 337     }
 338
 339     /* get until end of block reached */
 340     while ((avio_tell(pb) % ffm->packet_size) != 0)
 341         avio_r8(pb);
 342
 343     /* init packet demux */
 344     ffm->packet_ptr = ffm->packet;
 345     ffm->packet_end = ffm->packet;
 346     ffm->frame_offset = 0;
 347     ffm->dts = 0;
 348     ffm->read_state = READ_HEADER;
 349     ffm->first_packet = 1;
 350     return 0;
 351  fail:
 352     ffm_close(s);
 353     return -1;
 354 }
 355
 356 /* return < 0 if eof */
 357 static int ffm_read_packet(AVFormatContext *s, AVPacket *pkt)
 358 {
 359     int size;
 360     FFMContext *ffm = s->priv_data;
 361     int duration, ret;
 362
 363     switch(ffm->read_state) {
 364     case READ_HEADER:
 365         if ((ret = ffm_is_avail_data(s, FRAME_HEADER_SIZE+4)) < 0)
 366             return ret;
 367
 368         av_dlog(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",
 369                avio_tell(s->pb), s->pb->pos, ffm->write_index, ffm->file_size);
 370         if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=
 371             FRAME_HEADER_SIZE)
 372             return -1;
 373         if (ffm->header[1] & FLAG_DTS)
 374             if (ffm_read_data(s, ffm->header+16, 4, 1) != 4)
 375                 return -1;
 376         ffm->read_state = READ_DATA;
 377         /* fall thru */
 378     case READ_DATA:
 379         size = AV_RB24(ffm->header + 2);
 380         if ((ret = ffm_is_avail_data(s, size)) < 0)
 381             return ret;
 382
 383         duration = AV_RB24(ffm->header + 5);
 384
 385         av_new_packet(pkt, size);
 386         pkt->stream_index = ffm->header[0];
 387         if ((unsigned)pkt->stream_index >= s->nb_streams) {
 388             av_log(s, AV_LOG_ERROR, "invalid stream index %d\n", pkt->stream_index);
 389             av_free_packet(pkt);
 390             ffm->read_state = READ_HEADER;
 391             return -1;
 392         }
 393         pkt->pos = avio_tell(s->pb);
 394         if (ffm->header[1] & FLAG_KEY_FRAME)
 395             pkt->flags |= AV_PKT_FLAG_KEY;
 396
 397         ffm->read_state = READ_HEADER;
 398         if (ffm_read_data(s, pkt->data, size, 0) != size) {
 399             /* bad case: desynchronized packet. we cancel all the packet loading */
 400             av_free_packet(pkt);
 401             return -1;
 402         }
 403         pkt->pts = AV_RB64(ffm->header+8);
 404         if (ffm->header[1] & FLAG_DTS)
 405             pkt->dts = pkt->pts - AV_RB32(ffm->header+16);
 406         else
 407             pkt->dts = pkt->pts;
 408         pkt->duration = duration;
 409         break;
 410     }
 411     return 0;
 412 }
 413
 414 /* seek to a given time in the file. The file read pointer is
 415    positioned at or before pts. XXX: the following code is quite
 416    approximative */
 417 static int ffm_seek(AVFormatContext *s, int stream_index, int64_t wanted_pts, int flags)
 418 {
 419     FFMContext *ffm = s->priv_data;
 420     int64_t pos_min, pos_max, pos;
 421     int64_t pts_min, pts_max, pts;
 422     double pos1;
 423
 424     av_dlog(s, "wanted_pts=%0.6f\n", wanted_pts / 1000000.0);
 425     /* find the position using linear interpolation (better than
 426        dichotomy in typical cases) */
 427     pos_min = FFM_PACKET_SIZE;
 428     pos_max = ffm->file_size - FFM_PACKET_SIZE;
 429     while (pos_min <= pos_max) {
 430         pts_min = get_dts(s, pos_min);
 431         pts_max = get_dts(s, pos_max);
 432         /* linear interpolation */
 433         pos1 = (double)(pos_max - pos_min) * (double)(wanted_pts - pts_min) /
 434             (double)(pts_max - pts_min);
 435         pos = (((int64_t)pos1) / FFM_PACKET_SIZE) * FFM_PACKET_SIZE;
 436         if (pos <= pos_min)
 437             pos = pos_min;
 438         else if (pos >= pos_max)
 439             pos = pos_max;
 440         pts = get_dts(s, pos);
 441         /* check if we are lucky */
 442         if (pts == wanted_pts) {
 443             goto found;
 444         } else if (pts > wanted_pts) {
 445             pos_max = pos - FFM_PACKET_SIZE;
 446         } else {
 447             pos_min = pos + FFM_PACKET_SIZE;
 448         }
 449     }
 450     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
 451
 452  found:
 453     if (ffm_seek1(s, pos) < 0)
 454         return -1;
 455
 456     /* reset read state */
 457     ffm->read_state = READ_HEADER;
 458     ffm->packet_ptr = ffm->packet;
 459     ffm->packet_end = ffm->packet;
 460     ffm->first_packet = 1;
 461
 462     return 0;
 463 }
 464
 465 static int ffm_probe(AVProbeData *p)
 466 {
 467     if (
 468         p->buf[0] == 'F' && p->buf[1] == 'F' && p->buf[2] == 'M' &&
 469         p->buf[3] == '1')
 470         return AVPROBE_SCORE_MAX + 1;
 471     return 0;
 472 }
 473
 474 AVInputFormat ff_ffm_demuxer = {
 475     .name           = "ffm",
 476     .long_name      = NULL_IF_CONFIG_SMALL("FFM (AVserver live feed)"),
 477     .priv_data_size = sizeof(FFMContext),
 478     .read_probe     = ffm_probe,
 479     .read_header    = ffm_read_header,
 480     .read_packet    = ffm_read_packet,
 481     .read_close     = ffm_close,
 482     .read_seek      = ffm_seek,
 483 };