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.

224 lines
5.0KB

  1. /*
  2. * Multipart JPEG format
  3. * Copyright (c) 2015 Luca Barbato
  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. #include "libavutil/avstring.h"
  22. #include "avformat.h"
  23. #include "internal.h"
  24. static int get_line(AVIOContext *pb, char *line, int line_size)
  25. {
  26. int i = ff_get_line(pb, line, line_size);
  27. if (i > 1 && line[i - 2] == '\r')
  28. line[i - 2] = '\0';
  29. if (pb->error)
  30. return pb->error;
  31. if (pb->eof_reached)
  32. return AVERROR_EOF;
  33. return 0;
  34. }
  35. static int split_tag_value(char **tag, char **value, char *line)
  36. {
  37. char *p = line;
  38. while (*p != '\0' && *p != ':')
  39. p++;
  40. if (*p != ':')
  41. return AVERROR_INVALIDDATA;
  42. *p = '\0';
  43. *tag = line;
  44. p++;
  45. while (av_isspace(*p))
  46. p++;
  47. *value = p;
  48. return 0;
  49. }
  50. static int check_content_type(char *line)
  51. {
  52. char *tag, *value;
  53. int ret = split_tag_value(&tag, &value, line);
  54. if (ret < 0)
  55. return ret;
  56. if (av_strcasecmp(tag, "Content-type") ||
  57. av_strcasecmp(value, "image/jpeg"))
  58. return AVERROR_INVALIDDATA;
  59. return 0;
  60. }
  61. static int mpjpeg_read_probe(AVProbeData *p)
  62. {
  63. AVIOContext *pb;
  64. char line[128] = { 0 };
  65. int ret = 0;
  66. if (p->buf_size < 2 || p->buf[0] != '-' || p->buf[1] != '-')
  67. return 0;
  68. pb = avio_alloc_context(p->buf, p->buf_size, 0, NULL, NULL, NULL, NULL);
  69. if (!pb)
  70. return AVERROR(ENOMEM);
  71. while (!pb->eof_reached) {
  72. ret = get_line(pb, line, sizeof(line));
  73. if (ret < 0)
  74. break;
  75. ret = check_content_type(line);
  76. if (!ret) {
  77. ret = AVPROBE_SCORE_MAX;
  78. break;
  79. }
  80. }
  81. av_free(pb);
  82. return ret;
  83. }
  84. static int mpjpeg_read_header(AVFormatContext *s)
  85. {
  86. AVStream *st;
  87. char boundary[70 + 2 + 1];
  88. int64_t pos = avio_tell(s->pb);
  89. int ret;
  90. ret = get_line(s->pb, boundary, sizeof(boundary));
  91. if (ret < 0)
  92. return ret;
  93. if (strncmp(boundary, "--", 2))
  94. return AVERROR_INVALIDDATA;
  95. st = avformat_new_stream(s, NULL);
  96. st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  97. st->codec->codec_id = AV_CODEC_ID_MJPEG;
  98. avpriv_set_pts_info(st, 60, 1, 25);
  99. avio_seek(s->pb, pos, SEEK_SET);
  100. return 0;
  101. }
  102. static int parse_content_length(const char *value)
  103. {
  104. long int val = strtol(value, NULL, 10);
  105. if (val == LONG_MIN || val == LONG_MAX)
  106. return AVERROR(errno);
  107. if (val > INT_MAX)
  108. return AVERROR(ERANGE);
  109. return val;
  110. }
  111. static int parse_multipart_header(AVFormatContext *s)
  112. {
  113. char line[128];
  114. int found_content_type = 0;
  115. int ret, size = -1;
  116. ret = get_line(s->pb, line, sizeof(line));
  117. if (ret < 0)
  118. return ret;
  119. if (strncmp(line, "--", 2))
  120. return AVERROR_INVALIDDATA;
  121. while (!s->pb->eof_reached) {
  122. char *tag, *value;
  123. ret = get_line(s->pb, line, sizeof(line));
  124. if (ret < 0)
  125. return ret;
  126. if (line[0] == '\0')
  127. break;
  128. ret = split_tag_value(&tag, &value, line);
  129. if (ret < 0)
  130. return ret;
  131. if (!av_strcasecmp(tag, "Content-type")) {
  132. if (av_strcasecmp(value, "image/jpeg")) {
  133. av_log(s, AV_LOG_ERROR,
  134. "Unexpected %s : %s\n",
  135. tag, value);
  136. return AVERROR_INVALIDDATA;
  137. } else
  138. found_content_type = 1;
  139. } else if (!av_strcasecmp(tag, "Content-Length")) {
  140. size = parse_content_length(value);
  141. if (size < 0)
  142. return size;
  143. }
  144. }
  145. if (!found_content_type || size < 0) {
  146. return AVERROR_INVALIDDATA;
  147. }
  148. return size;
  149. }
  150. static int mpjpeg_read_packet(AVFormatContext *s, AVPacket *pkt)
  151. {
  152. int ret;
  153. int size = parse_multipart_header(s);
  154. if (size < 0)
  155. return size;
  156. ret = av_get_packet(s->pb, pkt, size);
  157. if (ret < 0)
  158. return ret;
  159. // trailing empty line
  160. avio_skip(s->pb, 2);
  161. return 0;
  162. }
  163. AVInputFormat ff_mpjpeg_demuxer = {
  164. .name = "mpjpeg",
  165. .long_name = NULL_IF_CONFIG_SMALL("MIME multipart JPEG"),
  166. .mime_type = "multipart/x-mixed-replace",
  167. .extensions = "mjpg",
  168. .read_probe = mpjpeg_read_probe,
  169. .read_header = mpjpeg_read_header,
  170. .read_packet = mpjpeg_read_packet,
  171. };