falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13753 Commits
32 Branches
522MB
Tree: 42b9f45c0d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '42b9f45c0d'
${ noResults }
FFmpeg/libavformat/ffm.c

784 lines
22KB
Raw Blame History 

  1. /*

  2.  * FFM (ffserver live feed) muxer and demuxer

  3.  * Copyright (c) 2001 Fabrice Bellard.

  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. #include "avformat.h"

  22. #include <unistd.h>

  23. 

  24. /* The FFM file is made of blocks of fixed size */

  25. #define FFM_HEADER_SIZE 14

  26. #define PACKET_ID       0x666d

  27. 

  28. /* each packet contains frames (which can span several packets */

  29. #define FRAME_HEADER_SIZE    8

  30. #define FLAG_KEY_FRAME       0x01

  31. 

  32. typedef struct FFMStream {

  33.     int64_t pts;

  34. } FFMStream;

  35. 

  36. enum {

  37.     READ_HEADER,

  38.     READ_DATA,

  39. };

  40. 

  41. typedef struct FFMContext {

  42.     /* only reading mode */

  43.     offset_t write_index, file_size;

  44.     int read_state;

  45.     uint8_t header[FRAME_HEADER_SIZE];

  46. 

  47.     /* read and write */

  48.     int first_packet; /* true if first packet, needed to set the discontinuity tag */

  49.     int first_frame_in_packet; /* true if first frame in packet, needed to know if PTS information is valid */

  50.     int packet_size;

  51.     int frame_offset;

  52.     int64_t pts;

  53.     uint8_t *packet_ptr, *packet_end;

  54.     uint8_t packet[FFM_PACKET_SIZE];

  55. } FFMContext;

  56. 

  57. static int64_t get_pts(AVFormatContext *s, offset_t pos);

  58. 

  59. /* disable pts hack for testing */

  60. int ffm_nopts = 0;

  61. 

  62. #ifdef CONFIG_MUXERS

  63. static void flush_packet(AVFormatContext *s)

  64. {

  65.     FFMContext *ffm = s->priv_data;

  66.     int fill_size, h;

  67.     ByteIOContext *pb = s->pb;

  68. 

  69.     fill_size = ffm->packet_end - ffm->packet_ptr;

  70.     memset(ffm->packet_ptr, 0, fill_size);

  71. 

  72.     if (url_ftell(pb) % ffm->packet_size)

  73.         av_abort();

  74. 

  75.     /* put header */

  76.     put_be16(pb, PACKET_ID);

  77.     put_be16(pb, fill_size);

  78.     put_be64(pb, ffm->pts);

  79.     h = ffm->frame_offset;

  80.     if (ffm->first_packet)

  81.         h |= 0x8000;

  82.     put_be16(pb, h);

  83.     put_buffer(pb, ffm->packet, ffm->packet_end - ffm->packet);

  84.     put_flush_packet(pb);

  85. 

  86.     /* prepare next packet */

  87.     ffm->frame_offset = 0; /* no key frame */

  88.     ffm->pts = 0; /* no pts */

  89.     ffm->packet_ptr = ffm->packet;

  90.     ffm->first_packet = 0;

  91. }

  92. 

  93. /* 'first' is true if first data of a frame */

  94. static void ffm_write_data(AVFormatContext *s,

  95.                            const uint8_t *buf, int size,

  96.                            int64_t pts, int first)

  97. {

  98.     FFMContext *ffm = s->priv_data;

  99.     int len;

  100. 

  101.     if (first && ffm->frame_offset == 0)

  102.         ffm->frame_offset = ffm->packet_ptr - ffm->packet + FFM_HEADER_SIZE;

  103.     if (first && ffm->pts == 0)

  104.         ffm->pts = pts;

  105. 

  106.     /* write as many packets as needed */

  107.     while (size > 0) {

  108.         len = ffm->packet_end - ffm->packet_ptr;

  109.         if (len > size)

  110.             len = size;

  111.         memcpy(ffm->packet_ptr, buf, len);

  112. 

  113.         ffm->packet_ptr += len;

  114.         buf += len;

  115.         size -= len;

  116.         if (ffm->packet_ptr >= ffm->packet_end) {

  117.             /* special case : no pts in packet : we leave the current one */

  118.             if (ffm->pts == 0)

  119.                 ffm->pts = pts;

  120. 

  121.             flush_packet(s);

  122.         }

  123.     }

  124. }

  125. 

  126. static int ffm_write_header(AVFormatContext *s)

  127. {

  128.     FFMContext *ffm = s->priv_data;

  129.     AVStream *st;

  130.     FFMStream *fst;

  131.     ByteIOContext *pb = s->pb;

  132.     AVCodecContext *codec;

  133.     int bit_rate, i;

  134. 

  135.     ffm->packet_size = FFM_PACKET_SIZE;

  136. 

  137.     /* header */

  138.     put_le32(pb, MKTAG('F', 'F', 'M', '1'));

  139.     put_be32(pb, ffm->packet_size);

  140.     /* XXX: store write position in other file ? */

  141.     put_be64(pb, ffm->packet_size); /* current write position */

  142. 

  143.     put_be32(pb, s->nb_streams);

  144.     bit_rate = 0;

  145.     for(i=0;i<s->nb_streams;i++) {

  146.         st = s->streams[i];

  147.         bit_rate += st->codec->bit_rate;

  148.     }

  149.     put_be32(pb, bit_rate);

  150. 

  151.     /* list of streams */

  152.     for(i=0;i<s->nb_streams;i++) {

  153.         st = s->streams[i];

  154.         fst = av_mallocz(sizeof(FFMStream));

  155.         if (!fst)

  156.             goto fail;

  157.         av_set_pts_info(st, 64, 1, 1000000);

  158.         st->priv_data = fst;

  159. 

  160.         codec = st->codec;

  161.         /* generic info */

  162.         put_be32(pb, codec->codec_id);

  163.         put_byte(pb, codec->codec_type);

  164.         put_be32(pb, codec->bit_rate);

  165.         put_be32(pb, st->quality);

  166.         put_be32(pb, codec->flags);

  167.         put_be32(pb, codec->flags2);

  168.         put_be32(pb, codec->debug);

  169.         /* specific info */

  170.         switch(codec->codec_type) {

  171.         case CODEC_TYPE_VIDEO:

  172.             put_be32(pb, codec->time_base.num);

  173.             put_be32(pb, codec->time_base.den);

  174.             put_be16(pb, codec->width);

  175.             put_be16(pb, codec->height);

  176.             put_be16(pb, codec->gop_size);

  177.             put_be32(pb, codec->pix_fmt);

  178.             put_byte(pb, codec->qmin);

  179.             put_byte(pb, codec->qmax);

  180.             put_byte(pb, codec->max_qdiff);

  181.             put_be16(pb, (int) (codec->qcompress * 10000.0));

  182.             put_be16(pb, (int) (codec->qblur * 10000.0));

  183.             put_be32(pb, codec->bit_rate_tolerance);

  184.             put_strz(pb, codec->rc_eq);

  185.             put_be32(pb, codec->rc_max_rate);

  186.             put_be32(pb, codec->rc_min_rate);

  187.             put_be32(pb, codec->rc_buffer_size);

  188.             put_be64(pb, av_dbl2int(codec->i_quant_factor));

  189.             put_be64(pb, av_dbl2int(codec->b_quant_factor));

  190.             put_be64(pb, av_dbl2int(codec->i_quant_offset));

  191.             put_be64(pb, av_dbl2int(codec->b_quant_offset));

  192.             put_be32(pb, codec->dct_algo);

  193.             put_be32(pb, codec->strict_std_compliance);

  194.             put_be32(pb, codec->max_b_frames);

  195.             put_be32(pb, codec->luma_elim_threshold);

  196.             put_be32(pb, codec->chroma_elim_threshold);

  197.             put_be32(pb, codec->mpeg_quant);

  198.             put_be32(pb, codec->intra_dc_precision);

  199.             put_be32(pb, codec->me_method);

  200.             put_be32(pb, codec->mb_decision);

  201.             put_be32(pb, codec->nsse_weight);

  202.             put_be32(pb, codec->frame_skip_cmp);

  203.             put_be64(pb, av_dbl2int(codec->rc_buffer_aggressivity));

  204.             put_be32(pb, codec->codec_tag);

  205.             break;

  206.         case CODEC_TYPE_AUDIO:

  207.             put_be32(pb, codec->sample_rate);

  208.             put_le16(pb, codec->channels);

  209.             put_le16(pb, codec->frame_size);

  210.             break;

  211.         default:

  212.             return -1;

  213.         }

  214.         /* hack to have real time */

  215.         if (ffm_nopts)

  216.             fst->pts = 0;

  217.         else

  218.             fst->pts = av_gettime();

  219.     }

  220. 

  221.     /* flush until end of block reached */

  222.     while ((url_ftell(pb) % ffm->packet_size) != 0)

  223.         put_byte(pb, 0);

  224. 

  225.     put_flush_packet(pb);

  226. 

  227.     /* init packet mux */

  228.     ffm->packet_ptr = ffm->packet;

  229.     ffm->packet_end = ffm->packet + ffm->packet_size - FFM_HEADER_SIZE;

  230.     assert(ffm->packet_end >= ffm->packet);

  231.     ffm->frame_offset = 0;

  232.     ffm->pts = 0;

  233.     ffm->first_packet = 1;

  234. 

  235.     return 0;

  236.  fail:

  237.     for(i=0;i<s->nb_streams;i++) {

  238.         st = s->streams[i];

  239.         av_freep(&st->priv_data);

  240.     }

  241.     return -1;

  242. }

  243. 

  244. static int ffm_write_packet(AVFormatContext *s, AVPacket *pkt)

  245. {

  246.     AVStream *st = s->streams[pkt->stream_index];

  247.     FFMStream *fst = st->priv_data;

  248.     int64_t pts;

  249.     uint8_t header[FRAME_HEADER_SIZE];

  250.     int size= pkt->size;

  251. 

  252.     pts = fst->pts;

  253.     /* packet size & key_frame */

  254.     header[0] = pkt->stream_index;

  255.     header[1] = 0;

  256.     if (pkt->flags & PKT_FLAG_KEY)

  257.         header[1] |= FLAG_KEY_FRAME;

  258.     AV_WB24(header+2, size);

  259.     AV_WB24(header+5, pkt->duration);

  260.     ffm_write_data(s, header, FRAME_HEADER_SIZE, pts, 1);

  261.     ffm_write_data(s, pkt->data, size, pts, 0);

  262. 

  263.     fst->pts += pkt->duration;

  264.     return 0;

  265. }

  266. 

  267. static int ffm_write_trailer(AVFormatContext *s)

  268. {

  269.     ByteIOContext *pb = s->pb;

  270.     FFMContext *ffm = s->priv_data;

  271. 

  272.     /* flush packets */

  273.     if (ffm->packet_ptr > ffm->packet)

  274.         flush_packet(s);

  275. 

  276.     put_flush_packet(pb);

  277. 

  278.     if (!url_is_streamed(pb)) {

  279.         int64_t size;

  280.         /* update the write offset */

  281.         size = url_ftell(pb);

  282.         url_fseek(pb, 8, SEEK_SET);

  283.         put_be64(pb, size);

  284.         put_flush_packet(pb);

  285.     }

  286. 

  287.     return 0;

  288. }

  289. #endif //CONFIG_MUXERS

  290. 

  291. /* ffm demux */

  292. 

  293. static int ffm_is_avail_data(AVFormatContext *s, int size)

  294. {

  295.     FFMContext *ffm = s->priv_data;

  296.     offset_t pos, avail_size;

  297.     int len;

  298. 

  299.     len = ffm->packet_end - ffm->packet_ptr;

  300.     if (!ffm_nopts) {

  301.         /* XXX: I don't understand this test, so I disabled it for testing */

  302.         if (size <= len)

  303.             return 1;

  304.     }

  305.     pos = url_ftell(s->pb);

  306.     if (pos == ffm->write_index) {

  307.         /* exactly at the end of stream */

  308.         return 0;

  309.     } else if (pos < ffm->write_index) {

  310.         avail_size = ffm->write_index - pos;

  311.     } else {

  312.         avail_size = (ffm->file_size - pos) + (ffm->write_index - FFM_PACKET_SIZE);

  313.     }

  314.     avail_size = (avail_size / ffm->packet_size) * (ffm->packet_size - FFM_HEADER_SIZE) + len;

  315.     if (size <= avail_size)

  316.         return 1;

  317.     else

  318.         return 0;

  319. }

  320. 

  321. /* first is true if we read the frame header */

  322. static int ffm_read_data(AVFormatContext *s,

  323.                          uint8_t *buf, int size, int first)

  324. {

  325.     FFMContext *ffm = s->priv_data;

  326.     ByteIOContext *pb = s->pb;

  327.     int len, fill_size, size1, frame_offset;

  328. 

  329.     size1 = size;

  330.     while (size > 0) {

  331.     redo:

  332.         len = ffm->packet_end - ffm->packet_ptr;

  333.         if (len > size)

  334.             len = size;

  335.         if (len == 0) {

  336.             if (url_ftell(pb) == ffm->file_size)

  337.                 url_fseek(pb, ffm->packet_size, SEEK_SET);

  338.     retry_read:

  339.             get_be16(pb); /* PACKET_ID */

  340.             fill_size = get_be16(pb);

  341.             ffm->pts = get_be64(pb);

  342.             ffm->first_frame_in_packet = 1;

  343.             frame_offset = get_be16(pb);

  344.             get_buffer(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);

  345.             ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);

  346.             if (ffm->packet_end < ffm->packet)

  347.                 return -1;

  348.             /* if first packet or resynchronization packet, we must

  349.                handle it specifically */

  350.             if (ffm->first_packet || (frame_offset & 0x8000)) {

  351.                 if (!frame_offset) {

  352.                     /* This packet has no frame headers in it */

  353.                     if (url_ftell(pb) >= ffm->packet_size * 3) {

  354.                         url_fseek(pb, -ffm->packet_size * 2, SEEK_CUR);

  355.                         goto retry_read;

  356.                     }

  357.                     /* This is bad, we cannot find a valid frame header */

  358.                     return 0;

  359.                 }

  360.                 ffm->first_packet = 0;

  361.                 if ((frame_offset & 0x7ffff) < FFM_HEADER_SIZE)

  362.                     return -1;

  363.                 ffm->packet_ptr = ffm->packet + (frame_offset & 0x7fff) - FFM_HEADER_SIZE;

  364.                 if (!first)

  365.                     break;

  366.             } else {

  367.                 ffm->packet_ptr = ffm->packet;

  368.             }

  369.             goto redo;

  370.         }

  371.         memcpy(buf, ffm->packet_ptr, len);

  372.         buf += len;

  373.         ffm->packet_ptr += len;

  374.         size -= len;

  375.         first = 0;

  376.     }

  377.     return size1 - size;

  378. }

  379. 

  380. 

  381. static void adjust_write_index(AVFormatContext *s)

  382. {

  383.     FFMContext *ffm = s->priv_data;

  384.     ByteIOContext *pb = s->pb;

  385.     int64_t pts;

  386.     //offset_t orig_write_index = ffm->write_index;

  387.     offset_t pos_min, pos_max;

  388.     int64_t pts_start;

  389.     offset_t ptr = url_ftell(pb);

  390. 

  391. 

  392.     pos_min = 0;

  393.     pos_max = ffm->file_size - 2 * FFM_PACKET_SIZE;

  394. 

  395.     pts_start = get_pts(s, pos_min);

  396. 

  397.     pts = get_pts(s, pos_max);

  398. 

  399.     if (pts - 100000 > pts_start)

  400.         goto end;

  401. 

  402.     ffm->write_index = FFM_PACKET_SIZE;

  403. 

  404.     pts_start = get_pts(s, pos_min);

  405. 

  406.     pts = get_pts(s, pos_max);

  407. 

  408.     if (pts - 100000 <= pts_start) {

  409.         while (1) {

  410.             offset_t newpos;

  411.             int64_t newpts;

  412. 

  413.             newpos = ((pos_max + pos_min) / (2 * FFM_PACKET_SIZE)) * FFM_PACKET_SIZE;

  414. 

  415.             if (newpos == pos_min)

  416.                 break;

  417. 

  418.             newpts = get_pts(s, newpos);

  419. 

  420.             if (newpts - 100000 <= pts) {

  421.                 pos_max = newpos;

  422.                 pts = newpts;

  423.             } else {

  424.                 pos_min = newpos;

  425.             }

  426.         }

  427.         ffm->write_index += pos_max;

  428.     }

  429. 

  430.     //printf("Adjusted write index from %"PRId64" to %"PRId64": pts=%0.6f\n", orig_write_index, ffm->write_index, pts / 1000000.);

  431.     //printf("pts range %0.6f - %0.6f\n", get_pts(s, 0) / 1000000. , get_pts(s, ffm->file_size - 2 * FFM_PACKET_SIZE) / 1000000. );

  432. 

  433.  end:

  434.     url_fseek(pb, ptr, SEEK_SET);

  435. }

  436. 

  437. 

  438. static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)

  439. {

  440.     FFMContext *ffm = s->priv_data;

  441.     AVStream *st;

  442.     FFMStream *fst;

  443.     ByteIOContext *pb = s->pb;

  444.     AVCodecContext *codec;

  445.     int i, nb_streams;

  446.     uint32_t tag;

  447. 

  448.     /* header */

  449.     tag = get_le32(pb);

  450.     if (tag != MKTAG('F', 'F', 'M', '1'))

  451.         goto fail;

  452.     ffm->packet_size = get_be32(pb);

  453.     if (ffm->packet_size != FFM_PACKET_SIZE)

  454.         goto fail;

  455.     ffm->write_index = get_be64(pb);

  456.     /* get also filesize */

  457.     if (!url_is_streamed(pb)) {

  458.         ffm->file_size = url_fsize(pb);

  459.         adjust_write_index(s);

  460.     } else {

  461.         ffm->file_size = (UINT64_C(1) << 63) - 1;

  462.     }

  463. 

  464.     nb_streams = get_be32(pb);

  465.     get_be32(pb); /* total bitrate */

  466.     /* read each stream */

  467.     for(i=0;i<nb_streams;i++) {

  468.         char rc_eq_buf[128];

  469. 

  470.         st = av_new_stream(s, 0);

  471.         if (!st)

  472.             goto fail;

  473.         fst = av_mallocz(sizeof(FFMStream));

  474.         if (!fst)

  475.             goto fail;

  476.         s->streams[i] = st;

  477. 

  478.         av_set_pts_info(st, 64, 1, 1000000);

  479. 

  480.         st->priv_data = fst;

  481. 

  482.         codec = st->codec;

  483.         /* generic info */

  484.         codec->codec_id = get_be32(pb);

  485.         codec->codec_type = get_byte(pb); /* codec_type */

  486.         codec->bit_rate = get_be32(pb);

  487.         st->quality = get_be32(pb);

  488.         codec->flags = get_be32(pb);

  489.         codec->flags2 = get_be32(pb);

  490.         codec->debug = get_be32(pb);

  491.         /* specific info */

  492.         switch(codec->codec_type) {

  493.         case CODEC_TYPE_VIDEO:

  494.             codec->time_base.num = get_be32(pb);

  495.             codec->time_base.den = get_be32(pb);

  496.             codec->width = get_be16(pb);

  497.             codec->height = get_be16(pb);

  498.             codec->gop_size = get_be16(pb);

  499.             codec->pix_fmt = get_be32(pb);

  500.             codec->qmin = get_byte(pb);

  501.             codec->qmax = get_byte(pb);

  502.             codec->max_qdiff = get_byte(pb);

  503.             codec->qcompress = get_be16(pb) / 10000.0;

  504.             codec->qblur = get_be16(pb) / 10000.0;

  505.             codec->bit_rate_tolerance = get_be32(pb);

  506.             codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf)));

  507.             codec->rc_max_rate = get_be32(pb);

  508.             codec->rc_min_rate = get_be32(pb);

  509.             codec->rc_buffer_size = get_be32(pb);

  510.             codec->i_quant_factor = av_int2dbl(get_be64(pb));

  511.             codec->b_quant_factor = av_int2dbl(get_be64(pb));

  512.             codec->i_quant_offset = av_int2dbl(get_be64(pb));

  513.             codec->b_quant_offset = av_int2dbl(get_be64(pb));

  514.             codec->dct_algo = get_be32(pb);

  515.             codec->strict_std_compliance = get_be32(pb);

  516.             codec->max_b_frames = get_be32(pb);

  517.             codec->luma_elim_threshold = get_be32(pb);

  518.             codec->chroma_elim_threshold = get_be32(pb);

  519.             codec->mpeg_quant = get_be32(pb);

  520.             codec->intra_dc_precision = get_be32(pb);

  521.             codec->me_method = get_be32(pb);

  522.             codec->mb_decision = get_be32(pb);

  523.             codec->nsse_weight = get_be32(pb);

  524.             codec->frame_skip_cmp = get_be32(pb);

  525.             codec->rc_buffer_aggressivity = av_int2dbl(get_be64(pb));

  526.             codec->codec_tag = get_be32(pb);

  527.             break;

  528.         case CODEC_TYPE_AUDIO:

  529.             codec->sample_rate = get_be32(pb);

  530.             codec->channels = get_le16(pb);

  531.             codec->frame_size = get_le16(pb);

  532.             break;

  533.         default:

  534.             goto fail;

  535.         }

  536. 

  537.     }

  538. 

  539.     /* get until end of block reached */

  540.     while ((url_ftell(pb) % ffm->packet_size) != 0)

  541.         get_byte(pb);

  542. 

  543.     /* init packet demux */

  544.     ffm->packet_ptr = ffm->packet;

  545.     ffm->packet_end = ffm->packet;

  546.     ffm->frame_offset = 0;

  547.     ffm->pts = 0;

  548.     ffm->read_state = READ_HEADER;

  549.     ffm->first_packet = 1;

  550.     return 0;

  551.  fail:

  552.     for(i=0;i<s->nb_streams;i++) {

  553.         st = s->streams[i];

  554.         if (st) {

  555.             av_freep(&st->priv_data);

  556.             av_free(st);

  557.         }

  558.     }

  559.     return -1;

  560. }

  561. 

  562. /* return < 0 if eof */

  563. static int ffm_read_packet(AVFormatContext *s, AVPacket *pkt)

  564. {

  565.     int size;

  566.     FFMContext *ffm = s->priv_data;

  567.     int duration;

  568. 

  569.     switch(ffm->read_state) {

  570.     case READ_HEADER:

  571.         if (!ffm_is_avail_data(s, FRAME_HEADER_SIZE)) {

  572.             return AVERROR(EAGAIN);

  573.         }

  574. #if 0

  575.         printf("pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",

  576.                url_ftell(s->pb), s->pb.pos, ffm->write_index, ffm->file_size);

  577. #endif

  578.         if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=

  579.             FRAME_HEADER_SIZE)

  580.             return AVERROR(EAGAIN);

  581. #if 0

  582.         {

  583.             int i;

  584.             for(i=0;i<FRAME_HEADER_SIZE;i++)

  585.                 printf("%02x ", ffm->header[i]);

  586.             printf("\n");

  587.         }

  588. #endif

  589.         ffm->read_state = READ_DATA;

  590.         /* fall thru */

  591.     case READ_DATA:

  592.         size = AV_RB24(ffm->header + 2);

  593.         if (!ffm_is_avail_data(s, size)) {

  594.             return AVERROR(EAGAIN);

  595.         }

  596. 

  597.         duration = AV_RB24(ffm->header + 5);

  598. 

  599.         av_new_packet(pkt, size);

  600.         pkt->stream_index = ffm->header[0];

  601.         if ((unsigned)pkt->stream_index >= s->nb_streams) {

  602.             av_log(s, AV_LOG_ERROR, "invalid stream index %d\n", pkt->stream_index);

  603.             av_free_packet(pkt);

  604.             ffm->read_state = READ_HEADER;

  605.             return AVERROR(EAGAIN);

  606.         }

  607.         pkt->pos = url_ftell(s->pb);

  608.         if (ffm->header[1] & FLAG_KEY_FRAME)

  609.             pkt->flags |= PKT_FLAG_KEY;

  610. 

  611.         ffm->read_state = READ_HEADER;

  612.         if (ffm_read_data(s, pkt->data, size, 0) != size) {

  613.             /* bad case: desynchronized packet. we cancel all the packet loading */

  614.             av_free_packet(pkt);

  615.             return AVERROR(EAGAIN);

  616.         }

  617.         if (ffm->first_frame_in_packet)

  618.         {

  619.             pkt->pts = ffm->pts;

  620.             ffm->first_frame_in_packet = 0;

  621.         }

  622.         pkt->duration = duration;

  623.         break;

  624.     }

  625.     return 0;

  626. }

  627. 

  628. //#define DEBUG_SEEK

  629. 

  630. /* pos is between 0 and file_size - FFM_PACKET_SIZE. It is translated

  631.    by the write position inside this function */

  632. static void ffm_seek1(AVFormatContext *s, offset_t pos1)

  633. {

  634.     FFMContext *ffm = s->priv_data;

  635.     ByteIOContext *pb = s->pb;

  636.     offset_t pos;

  637. 

  638.     pos = pos1 + ffm->write_index;

  639.     if (pos >= ffm->file_size)

  640.         pos -= (ffm->file_size - FFM_PACKET_SIZE);

  641. #ifdef DEBUG_SEEK

  642.     printf("seek to %"PRIx64" -> %"PRIx64"\n", pos1, pos);

  643. #endif

  644.     url_fseek(pb, pos, SEEK_SET);

  645. }

  646. 

  647. static int64_t get_pts(AVFormatContext *s, offset_t pos)

  648. {

  649.     ByteIOContext *pb = s->pb;

  650.     int64_t pts;

  651. 

  652.     ffm_seek1(s, pos);

  653.     url_fskip(pb, 4);

  654.     pts = get_be64(pb);

  655. #ifdef DEBUG_SEEK

  656.     printf("pts=%0.6f\n", pts / 1000000.0);

  657. #endif

  658.     return pts;

  659. }

  660. 

  661. /* seek to a given time in the file. The file read pointer is

  662.    positioned at or before pts. XXX: the following code is quite

  663.    approximative */

  664. static int ffm_seek(AVFormatContext *s, int stream_index, int64_t wanted_pts, int flags)

  665. {

  666.     FFMContext *ffm = s->priv_data;

  667.     offset_t pos_min, pos_max, pos;

  668.     int64_t pts_min, pts_max, pts;

  669.     double pos1;

  670. 

  671. #ifdef DEBUG_SEEK

  672.     printf("wanted_pts=%0.6f\n", wanted_pts / 1000000.0);

  673. #endif

  674.     /* find the position using linear interpolation (better than

  675.        dichotomy in typical cases) */

  676.     pos_min = 0;

  677.     pos_max = ffm->file_size - 2 * FFM_PACKET_SIZE;

  678.     while (pos_min <= pos_max) {

  679.         pts_min = get_pts(s, pos_min);

  680.         pts_max = get_pts(s, pos_max);

  681.         /* linear interpolation */

  682.         pos1 = (double)(pos_max - pos_min) * (double)(wanted_pts - pts_min) /

  683.             (double)(pts_max - pts_min);

  684.         pos = (((int64_t)pos1) / FFM_PACKET_SIZE) * FFM_PACKET_SIZE;

  685.         if (pos <= pos_min)

  686.             pos = pos_min;

  687.         else if (pos >= pos_max)

  688.             pos = pos_max;

  689.         pts = get_pts(s, pos);

  690.         /* check if we are lucky */

  691.         if (pts == wanted_pts) {

  692.             goto found;

  693.         } else if (pts > wanted_pts) {

  694.             pos_max = pos - FFM_PACKET_SIZE;

  695.         } else {

  696.             pos_min = pos + FFM_PACKET_SIZE;

  697.         }

  698.     }

  699.     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;

  700.     if (pos > 0)

  701.         pos -= FFM_PACKET_SIZE;

  702.  found:

  703.     ffm_seek1(s, pos);

  704.     return 0;

  705. }

  706. 

  707. #ifdef CONFIG_FFSERVER

  708. offset_t ffm_read_write_index(int fd)

  709. {

  710.     uint8_t buf[8];

  711. 

  712.     lseek(fd, 8, SEEK_SET);

  713.     read(fd, buf, 8);

  714.     return AV_RB64(buf);

  715. }

  716. 

  717. void ffm_write_write_index(int fd, offset_t pos)

  718. {

  719.     uint8_t buf[8];

  720.     int i;

  721. 

  722.     for(i=0;i<8;i++)

  723.         buf[i] = (pos >> (56 - i * 8)) & 0xff;

  724.     lseek(fd, 8, SEEK_SET);

  725.     write(fd, buf, 8);

  726. }

  727. 

  728. void ffm_set_write_index(AVFormatContext *s, offset_t pos, offset_t file_size)

  729. {

  730.     FFMContext *ffm = s->priv_data;

  731.     ffm->write_index = pos;

  732.     ffm->file_size = file_size;

  733. }

  734. #endif // CONFIG_FFSERVER

  735. 

  736. static int ffm_read_close(AVFormatContext *s)

  737. {

  738.     AVStream *st;

  739.     int i;

  740. 

  741.     for(i=0;i<s->nb_streams;i++) {

  742.         st = s->streams[i];

  743.         av_freep(&st->priv_data);

  744.     }

  745.     return 0;

  746. }

  747. 

  748. static int ffm_probe(AVProbeData *p)

  749. {

  750.     if (

  751.         p->buf[0] == 'F' && p->buf[1] == 'F' && p->buf[2] == 'M' &&

  752.         p->buf[3] == '1')

  753.         return AVPROBE_SCORE_MAX + 1;

  754.     return 0;

  755. }

  756. 

  757. #ifdef CONFIG_FFM_DEMUXER

  758. AVInputFormat ffm_demuxer = {

  759.     "ffm",

  760.     "ffm format",

  761.     sizeof(FFMContext),

  762.     ffm_probe,

  763.     ffm_read_header,

  764.     ffm_read_packet,

  765.     ffm_read_close,

  766.     ffm_seek,

  767. };

  768. #endif

  769. #ifdef CONFIG_FFM_MUXER

  770. AVOutputFormat ffm_muxer = {

  771.     "ffm",

  772.     "ffm format",

  773.     "",

  774.     "ffm",

  775.     sizeof(FFMContext),

  776.     /* not really used */

  777.     CODEC_ID_MP2,

  778.     CODEC_ID_MPEG1VIDEO,

  779.     ffm_write_header,

  780.     ffm_write_packet,

  781.     ffm_write_trailer,

  782. };

  783. #endif //CONFIG_FFM_MUXER