rtpdec.c
Go to the documentation of this file.
1 /*
2  * RTP input format
3  * Copyright (c) 2002 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 "libavutil/mathematics.h"
23 #include "libavutil/avstring.h"
24 #include "libavcodec/get_bits.h"
25 #include "avformat.h"
26 #include "mpegts.h"
27 #include "url.h"
28 
29 #include <unistd.h>
30 #include "network.h"
31 
32 #include "rtpdec.h"
33 #include "rtpdec_formats.h"
34 
35 //#define DEBUG
36 
37 /* TODO: - add RTCP statistics reporting (should be optional).
38 
39  - add support for h263/mpeg4 packetized output : IDEA: send a
40  buffer to 'rtp_write_packet' contains all the packets for ONE
41  frame. Each packet should have a four byte header containing
42  the length in big endian format (same trick as
43  'ffio_open_dyn_packet_buf')
44 */
45 
47  .enc_name = "X-MP3-draft-00",
48  .codec_type = AVMEDIA_TYPE_AUDIO,
49  .codec_id = CODEC_ID_MP3ADU,
50 };
51 
52 /* statistics functions */
54 
56 {
58  RTPFirstDynamicPayloadHandler= handler;
59 }
60 
62 {
77  ff_register_dynamic_payload_handler(&ff_realmedia_mp3_dynamic_handler);
78 
81 
86 
91 }
92 
95 {
97  for (handler = RTPFirstDynamicPayloadHandler;
98  handler; handler = handler->next)
99  if (!av_strcasecmp(name, handler->enc_name) &&
100  codec_type == handler->codec_type)
101  return handler;
102  return NULL;
103 }
104 
106  enum AVMediaType codec_type)
107 {
108  RTPDynamicProtocolHandler *handler;
109  for (handler = RTPFirstDynamicPayloadHandler;
110  handler; handler = handler->next)
111  if (handler->static_payload_id && handler->static_payload_id == id &&
112  codec_type == handler->codec_type)
113  return handler;
114  return NULL;
115 }
116 
117 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
118 {
119  int payload_len;
120  while (len >= 4) {
121  payload_len = FFMIN(len, (AV_RB16(buf + 2) + 1) * 4);
122 
123  switch (buf[1]) {
124  case RTCP_SR:
125  if (payload_len < 20) {
126  av_log(NULL, AV_LOG_ERROR, "Invalid length for RTCP SR packet\n");
127  return AVERROR_INVALIDDATA;
128  }
129 
130  s->last_rtcp_ntp_time = AV_RB64(buf + 8);
131  s->last_rtcp_timestamp = AV_RB32(buf + 16);
134  if (!s->base_timestamp)
137  }
138 
139  break;
140  case RTCP_BYE:
141  return -RTCP_BYE;
142  }
143 
144  buf += payload_len;
145  len -= payload_len;
146  }
147  return -1;
148 }
149 
150 #define RTP_SEQ_MOD (1<<16)
151 
155 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
156 {
157  memset(s, 0, sizeof(RTPStatistics));
158  s->max_seq= base_sequence;
159  s->probation= 1;
160 }
161 
165 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
166 {
167  s->max_seq= seq;
168  s->cycles= 0;
169  s->base_seq= seq -1;
170  s->bad_seq= RTP_SEQ_MOD + 1;
171  s->received= 0;
172  s->expected_prior= 0;
173  s->received_prior= 0;
174  s->jitter= 0;
175  s->transit= 0;
176 }
177 
181 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
182 {
183  uint16_t udelta= seq - s->max_seq;
184  const int MAX_DROPOUT= 3000;
185  const int MAX_MISORDER = 100;
186  const int MIN_SEQUENTIAL = 2;
187 
188  /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
189  if(s->probation)
190  {
191  if(seq==s->max_seq + 1) {
192  s->probation--;
193  s->max_seq= seq;
194  if(s->probation==0) {
195  rtp_init_sequence(s, seq);
196  s->received++;
197  return 1;
198  }
199  } else {
200  s->probation= MIN_SEQUENTIAL - 1;
201  s->max_seq = seq;
202  }
203  } else if (udelta < MAX_DROPOUT) {
204  // in order, with permissible gap
205  if(seq < s->max_seq) {
206  //sequence number wrapped; count antother 64k cycles
207  s->cycles += RTP_SEQ_MOD;
208  }
209  s->max_seq= seq;
210  } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
211  // sequence made a large jump...
212  if(seq==s->bad_seq) {
213  // two sequential packets-- assume that the other side restarted without telling us; just resync.
214  rtp_init_sequence(s, seq);
215  } else {
216  s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
217  return 0;
218  }
219  } else {
220  // duplicate or reordered packet...
221  }
222  s->received++;
223  return 1;
224 }
225 
227 {
228  AVIOContext *pb;
229  uint8_t *buf;
230  int len;
231  int rtcp_bytes;
232  RTPStatistics *stats= &s->statistics;
233  uint32_t lost;
234  uint32_t extended_max;
235  uint32_t expected_interval;
236  uint32_t received_interval;
237  uint32_t lost_interval;
238  uint32_t expected;
239  uint32_t fraction;
240  uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
241 
242  if (!s->rtp_ctx || (count < 1))
243  return -1;
244 
245  /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
246  /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
247  s->octet_count += count;
248  rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
250  rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
251  if (rtcp_bytes < 28)
252  return -1;
254 
255  if (avio_open_dyn_buf(&pb) < 0)
256  return -1;
257 
258  // Receiver Report
259  avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
260  avio_w8(pb, RTCP_RR);
261  avio_wb16(pb, 7); /* length in words - 1 */
262  // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
263  avio_wb32(pb, s->ssrc + 1);
264  avio_wb32(pb, s->ssrc); // server SSRC
265  // some placeholders we should really fill...
266  // RFC 1889/p64
267  extended_max= stats->cycles + stats->max_seq;
268  expected= extended_max - stats->base_seq + 1;
269  lost= expected - stats->received;
270  lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
271  expected_interval= expected - stats->expected_prior;
272  stats->expected_prior= expected;
273  received_interval= stats->received - stats->received_prior;
274  stats->received_prior= stats->received;
275  lost_interval= expected_interval - received_interval;
276  if (expected_interval==0 || lost_interval<=0) fraction= 0;
277  else fraction = (lost_interval<<8)/expected_interval;
278 
279  fraction= (fraction<<24) | lost;
280 
281  avio_wb32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
282  avio_wb32(pb, extended_max); /* max sequence received */
283  avio_wb32(pb, stats->jitter>>4); /* jitter */
284 
286  {
287  avio_wb32(pb, 0); /* last SR timestamp */
288  avio_wb32(pb, 0); /* delay since last SR */
289  } else {
290  uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
291  uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
292 
293  avio_wb32(pb, middle_32_bits); /* last SR timestamp */
294  avio_wb32(pb, delay_since_last); /* delay since last SR */
295  }
296 
297  // CNAME
298  avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
299  avio_w8(pb, RTCP_SDES);
300  len = strlen(s->hostname);
301  avio_wb16(pb, (6 + len + 3) / 4); /* length in words - 1 */
302  avio_wb32(pb, s->ssrc);
303  avio_w8(pb, 0x01);
304  avio_w8(pb, len);
305  avio_write(pb, s->hostname, len);
306  // padding
307  for (len = (6 + len) % 4; len % 4; len++) {
308  avio_w8(pb, 0);
309  }
310 
311  avio_flush(pb);
312  len = avio_close_dyn_buf(pb, &buf);
313  if ((len > 0) && buf) {
314  int av_unused result;
315  av_dlog(s->ic, "sending %d bytes of RR\n", len);
316  result= ffurl_write(s->rtp_ctx, buf, len);
317  av_dlog(s->ic, "result from ffurl_write: %d\n", result);
318  av_free(buf);
319  }
320  return 0;
321 }
322 
324 {
325  AVIOContext *pb;
326  uint8_t *buf;
327  int len;
328 
329  /* Send a small RTP packet */
330  if (avio_open_dyn_buf(&pb) < 0)
331  return;
332 
333  avio_w8(pb, (RTP_VERSION << 6));
334  avio_w8(pb, 0); /* Payload type */
335  avio_wb16(pb, 0); /* Seq */
336  avio_wb32(pb, 0); /* Timestamp */
337  avio_wb32(pb, 0); /* SSRC */
338 
339  avio_flush(pb);
340  len = avio_close_dyn_buf(pb, &buf);
341  if ((len > 0) && buf)
342  ffurl_write(rtp_handle, buf, len);
343  av_free(buf);
344 
345  /* Send a minimal RTCP RR */
346  if (avio_open_dyn_buf(&pb) < 0)
347  return;
348 
349  avio_w8(pb, (RTP_VERSION << 6));
350  avio_w8(pb, RTCP_RR); /* receiver report */
351  avio_wb16(pb, 1); /* length in words - 1 */
352  avio_wb32(pb, 0); /* our own SSRC */
353 
354  avio_flush(pb);
355  len = avio_close_dyn_buf(pb, &buf);
356  if ((len > 0) && buf)
357  ffurl_write(rtp_handle, buf, len);
358  av_free(buf);
359 }
360 
361 
367 RTPDemuxContext *ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, int queue_size)
368 {
369  RTPDemuxContext *s;
370 
371  s = av_mallocz(sizeof(RTPDemuxContext));
372  if (!s)
373  return NULL;
374  s->payload_type = payload_type;
377  s->ic = s1;
378  s->st = st;
379  s->queue_size = queue_size;
380  rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
381  if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
382  s->ts = ff_mpegts_parse_open(s->ic);
383  if (s->ts == NULL) {
384  av_free(s);
385  return NULL;
386  }
387  } else {
388  switch(st->codec->codec_id) {
389  case CODEC_ID_MPEG1VIDEO:
390  case CODEC_ID_MPEG2VIDEO:
391  case CODEC_ID_MP2:
392  case CODEC_ID_MP3:
393  case CODEC_ID_MPEG4:
394  case CODEC_ID_H263:
395  case CODEC_ID_H264:
397  break;
398  case CODEC_ID_ADPCM_G722:
399  /* According to RFC 3551, the stream clock rate is 8000
400  * even if the sample rate is 16000. */
401  if (st->codec->sample_rate == 8000)
402  st->codec->sample_rate = 16000;
403  break;
404  default:
405  break;
406  }
407  }
408  // needed to send back RTCP RR in RTSP sessions
409  s->rtp_ctx = rtpc;
410  gethostname(s->hostname, sizeof(s->hostname));
411  return s;
412 }
413 
414 void
416  RTPDynamicProtocolHandler *handler)
417 {
418  s->dynamic_protocol_context = ctx;
419  s->parse_packet = handler->parse_packet;
420 }
421 
425 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
426 {
427  if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE)
428  return; /* Timestamp already set by depacketizer */
429  if (timestamp == RTP_NOTS_VALUE)
430  return;
431 
432  if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE && s->ic->nb_streams > 1) {
433  int64_t addend;
434  int delta_timestamp;
435 
436  /* compute pts from timestamp with received ntp_time */
437  delta_timestamp = timestamp - s->last_rtcp_timestamp;
438  /* convert to the PTS timebase */
439  addend = av_rescale(s->last_rtcp_ntp_time - s->first_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
440  pkt->pts = s->range_start_offset + s->rtcp_ts_offset + addend +
441  delta_timestamp;
442  return;
443  }
444 
445  if (!s->base_timestamp)
446  s->base_timestamp = timestamp;
447  /* assume that the difference is INT32_MIN < x < INT32_MAX, but allow the first timestamp to exceed INT32_MAX */
448  if (!s->timestamp)
449  s->unwrapped_timestamp += timestamp;
450  else
451  s->unwrapped_timestamp += (int32_t)(timestamp - s->timestamp);
452  s->timestamp = timestamp;
454 }
455 
457  const uint8_t *buf, int len)
458 {
459  unsigned int ssrc, h;
460  int payload_type, seq, ret, flags = 0;
461  int ext;
462  AVStream *st;
463  uint32_t timestamp;
464  int rv= 0;
465 
466  ext = buf[0] & 0x10;
467  payload_type = buf[1] & 0x7f;
468  if (buf[1] & 0x80)
469  flags |= RTP_FLAG_MARKER;
470  seq = AV_RB16(buf + 2);
471  timestamp = AV_RB32(buf + 4);
472  ssrc = AV_RB32(buf + 8);
473  /* store the ssrc in the RTPDemuxContext */
474  s->ssrc = ssrc;
475 
476  /* NOTE: we can handle only one payload type */
477  if (s->payload_type != payload_type)
478  return -1;
479 
480  st = s->st;
481  // only do something with this if all the rtp checks pass...
483  {
484  av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
485  payload_type, seq, ((s->seq + 1) & 0xffff));
486  return -1;
487  }
488 
489  if (buf[0] & 0x20) {
490  int padding = buf[len - 1];
491  if (len >= 12 + padding)
492  len -= padding;
493  }
494 
495  s->seq = seq;
496  len -= 12;
497  buf += 12;
498 
499  /* RFC 3550 Section 5.3.1 RTP Header Extension handling */
500  if (ext) {
501  if (len < 4)
502  return -1;
503  /* calculate the header extension length (stored as number
504  * of 32-bit words) */
505  ext = (AV_RB16(buf + 2) + 1) << 2;
506 
507  if (len < ext)
508  return -1;
509  // skip past RTP header extension
510  len -= ext;
511  buf += ext;
512  }
513 
514  if (!st) {
515  /* specific MPEG2TS demux support */
516  ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len);
517  /* The only error that can be returned from ff_mpegts_parse_packet
518  * is "no more data to return from the provided buffer", so return
519  * AVERROR(EAGAIN) for all errors */
520  if (ret < 0)
521  return AVERROR(EAGAIN);
522  if (ret < len) {
523  s->read_buf_size = len - ret;
524  memcpy(s->buf, buf + ret, s->read_buf_size);
525  s->read_buf_index = 0;
526  return 1;
527  }
528  return 0;
529  } else if (s->parse_packet) {
531  s->st, pkt, &timestamp, buf, len, flags);
532  } else {
533  // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise.
534  switch(st->codec->codec_id) {
535  case CODEC_ID_MP2:
536  case CODEC_ID_MP3:
537  /* better than nothing: skip mpeg audio RTP header */
538  if (len <= 4)
539  return -1;
540  h = AV_RB32(buf);
541  len -= 4;
542  buf += 4;
543  av_new_packet(pkt, len);
544  memcpy(pkt->data, buf, len);
545  break;
546  case CODEC_ID_MPEG1VIDEO:
547  case CODEC_ID_MPEG2VIDEO:
548  /* better than nothing: skip mpeg video RTP header */
549  if (len <= 4)
550  return -1;
551  h = AV_RB32(buf);
552  buf += 4;
553  len -= 4;
554  if (h & (1 << 26)) {
555  /* mpeg2 */
556  if (len <= 4)
557  return -1;
558  buf += 4;
559  len -= 4;
560  }
561  av_new_packet(pkt, len);
562  memcpy(pkt->data, buf, len);
563  break;
564  default:
565  av_new_packet(pkt, len);
566  memcpy(pkt->data, buf, len);
567  break;
568  }
569 
570  pkt->stream_index = st->index;
571  }
572 
573  // now perform timestamp things....
574  finalize_packet(s, pkt, timestamp);
575 
576  return rv;
577 }
578 
580 {
581  while (s->queue) {
582  RTPPacket *next = s->queue->next;
583  av_free(s->queue->buf);
584  av_free(s->queue);
585  s->queue = next;
586  }
587  s->seq = 0;
588  s->queue_len = 0;
589  s->prev_ret = 0;
590 }
591 
592 static void enqueue_packet(RTPDemuxContext *s, uint8_t *buf, int len)
593 {
594  uint16_t seq = AV_RB16(buf + 2);
595  RTPPacket *cur = s->queue, *prev = NULL, *packet;
596 
597  /* Find the correct place in the queue to insert the packet */
598  while (cur) {
599  int16_t diff = seq - cur->seq;
600  if (diff < 0)
601  break;
602  prev = cur;
603  cur = cur->next;
604  }
605 
606  packet = av_mallocz(sizeof(*packet));
607  if (!packet)
608  return;
609  packet->recvtime = av_gettime();
610  packet->seq = seq;
611  packet->len = len;
612  packet->buf = buf;
613  packet->next = cur;
614  if (prev)
615  prev->next = packet;
616  else
617  s->queue = packet;
618  s->queue_len++;
619 }
620 
622 {
623  return s->queue && s->queue->seq == (uint16_t) (s->seq + 1);
624 }
625 
627 {
628  return s->queue ? s->queue->recvtime : 0;
629 }
630 
632 {
633  int rv;
634  RTPPacket *next;
635 
636  if (s->queue_len <= 0)
637  return -1;
638 
639  if (!has_next_packet(s))
640  av_log(s->st ? s->st->codec : NULL, AV_LOG_WARNING,
641  "RTP: missed %d packets\n", s->queue->seq - s->seq - 1);
642 
643  /* Parse the first packet in the queue, and dequeue it */
644  rv = rtp_parse_packet_internal(s, pkt, s->queue->buf, s->queue->len);
645  next = s->queue->next;
646  av_free(s->queue->buf);
647  av_free(s->queue);
648  s->queue = next;
649  s->queue_len--;
650  return rv;
651 }
652 
654  uint8_t **bufptr, int len)
655 {
656  uint8_t* buf = bufptr ? *bufptr : NULL;
657  int ret, flags = 0;
658  uint32_t timestamp;
659  int rv= 0;
660 
661  if (!buf) {
662  /* If parsing of the previous packet actually returned 0 or an error,
663  * there's nothing more to be parsed from that packet, but we may have
664  * indicated that we can return the next enqueued packet. */
665  if (s->prev_ret <= 0)
666  return rtp_parse_queued_packet(s, pkt);
667  /* return the next packets, if any */
668  if(s->st && s->parse_packet) {
669  /* timestamp should be overwritten by parse_packet, if not,
670  * the packet is left with pts == AV_NOPTS_VALUE */
671  timestamp = RTP_NOTS_VALUE;
673  s->st, pkt, &timestamp, NULL, 0, flags);
674  finalize_packet(s, pkt, timestamp);
675  return rv;
676  } else {
677  // TODO: Move to a dynamic packet handler (like above)
678  if (s->read_buf_index >= s->read_buf_size)
679  return AVERROR(EAGAIN);
680  ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
681  s->read_buf_size - s->read_buf_index);
682  if (ret < 0)
683  return AVERROR(EAGAIN);
684  s->read_buf_index += ret;
685  if (s->read_buf_index < s->read_buf_size)
686  return 1;
687  else
688  return 0;
689  }
690  }
691 
692  if (len < 12)
693  return -1;
694 
695  if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
696  return -1;
697  if (buf[1] >= RTCP_SR && buf[1] <= RTCP_APP) {
698  return rtcp_parse_packet(s, buf, len);
699  }
700 
701  if ((s->seq == 0 && !s->queue) || s->queue_size <= 1) {
702  /* First packet, or no reordering */
703  return rtp_parse_packet_internal(s, pkt, buf, len);
704  } else {
705  uint16_t seq = AV_RB16(buf + 2);
706  int16_t diff = seq - s->seq;
707  if (diff < 0) {
708  /* Packet older than the previously emitted one, drop */
709  av_log(s->st ? s->st->codec : NULL, AV_LOG_WARNING,
710  "RTP: dropping old packet received too late\n");
711  return -1;
712  } else if (diff <= 1) {
713  /* Correct packet */
714  rv = rtp_parse_packet_internal(s, pkt, buf, len);
715  return rv;
716  } else {
717  /* Still missing some packet, enqueue this one. */
718  enqueue_packet(s, buf, len);
719  *bufptr = NULL;
720  /* Return the first enqueued packet if the queue is full,
721  * even if we're missing something */
722  if (s->queue_len >= s->queue_size)
723  return rtp_parse_queued_packet(s, pkt);
724  return -1;
725  }
726  }
727 }
728 
739  uint8_t **bufptr, int len)
740 {
741  int rv = rtp_parse_one_packet(s, pkt, bufptr, len);
742  s->prev_ret = rv;
743  while (rv == AVERROR(EAGAIN) && has_next_packet(s))
744  rv = rtp_parse_queued_packet(s, pkt);
745  return rv ? rv : has_next_packet(s);
746 }
747 
749 {
751  if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
753  }
754  av_free(s);
755 }
756 
757 int ff_parse_fmtp(AVStream *stream, PayloadContext *data, const char *p,
758  int (*parse_fmtp)(AVStream *stream,
759  PayloadContext *data,
760  char *attr, char *value))
761 {
762  char attr[256];
763  char *value;
764  int res;
765  int value_size = strlen(p) + 1;
766 
767  if (!(value = av_malloc(value_size))) {
768  av_log(stream, AV_LOG_ERROR, "Failed to allocate data for FMTP.");
769  return AVERROR(ENOMEM);
770  }
771 
772  // remove protocol identifier
773  while (*p && *p == ' ') p++; // strip spaces
774  while (*p && *p != ' ') p++; // eat protocol identifier
775  while (*p && *p == ' ') p++; // strip trailing spaces
776 
777  while (ff_rtsp_next_attr_and_value(&p,
778  attr, sizeof(attr),
779  value, value_size)) {
780 
781  res = parse_fmtp(stream, data, attr, value);
782  if (res < 0 && res != AVERROR_PATCHWELCOME) {
783  av_free(value);
784  return res;
785  }
786  }
787  av_free(value);
788  return 0;
789 }