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.
61054 Commits
32 Branches
283MB
Tree: ab5d46df16
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ab5d46df16'
${ noResults }
FFmpeg/libavformat/yuv4mpeg.c

611 lines
21KB
Raw Blame History 

  1. /*

  2.  * YUV4MPEG format

  3.  * Copyright (c) 2001, 2002, 2003 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. 

  22. #include "libavutil/pixdesc.h"

  23. #include "avformat.h"

  24. #include "internal.h"

  25. 

  26. #define Y4M_MAGIC "YUV4MPEG2"

  27. #define Y4M_FRAME_MAGIC "FRAME"

  28. #define Y4M_LINE_MAX 256

  29. 

  30. #if CONFIG_YUV4MPEGPIPE_MUXER

  31. static int yuv4_generate_header(AVFormatContext *s, char* buf)

  32. {

  33.     AVStream *st;

  34.     int width, height;

  35.     int raten, rated, aspectn, aspectd, n;

  36.     char inter;

  37.     const char *colorspace = "";

  38. 

  39.     st     = s->streams[0];

  40.     width  = st->codec->width;

  41.     height = st->codec->height;

  42. 

  43.     av_reduce(&raten, &rated, st->codec->time_base.den,

  44.               st->codec->time_base.num, (1UL << 31) - 1);

  45. 

  46.     aspectn = st->sample_aspect_ratio.num;

  47.     aspectd = st->sample_aspect_ratio.den;

  48. 

  49.     if (aspectn == 0 && aspectd == 1)

  50.         aspectd = 0;  // 0:0 means unknown

  51. 

  52.     inter = 'p'; /* progressive is the default */

  53.     if (st->codec->coded_frame && st->codec->coded_frame->interlaced_frame)

  54.         inter = st->codec->coded_frame->top_field_first ? 't' : 'b';

  55.     if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {

  56.         inter = 'p';

  57.     } else if (st->codec->field_order == AV_FIELD_TB || st->codec->field_order == AV_FIELD_TT) {

  58.         inter = 't';

  59.     } else if (st->codec->field_order == AV_FIELD_BT || st->codec->field_order == AV_FIELD_BB) {

  60.         inter = 'b';

  61.     }

  62. 

  63.     switch (st->codec->pix_fmt) {

  64.     case AV_PIX_FMT_GRAY8:

  65.         colorspace = " Cmono";

  66.         break;

  67.     case AV_PIX_FMT_GRAY16:

  68.         colorspace = " Cmono16";

  69.         break;

  70.     case AV_PIX_FMT_YUV411P:

  71.         colorspace = " C411 XYSCSS=411";

  72.         break;

  73.     case AV_PIX_FMT_YUV420P:

  74.         switch (st->codec->chroma_sample_location) {

  75.         case AVCHROMA_LOC_TOPLEFT: colorspace = " C420paldv XYSCSS=420PALDV"; break;

  76.         case AVCHROMA_LOC_LEFT:    colorspace = " C420mpeg2 XYSCSS=420MPEG2"; break;

  77.         default:                   colorspace = " C420jpeg XYSCSS=420JPEG";   break;

  78.         }

  79.         break;

  80.     case AV_PIX_FMT_YUV422P:

  81.         colorspace = " C422 XYSCSS=422";

  82.         break;

  83.     case AV_PIX_FMT_YUV444P:

  84.         colorspace = " C444 XYSCSS=444";

  85.         break;

  86.     case AV_PIX_FMT_YUV420P9:

  87.         colorspace = " C420p9 XYSCSS=420P9";

  88.         break;

  89.     case AV_PIX_FMT_YUV422P9:

  90.         colorspace = " C422p9 XYSCSS=422P9";

  91.         break;

  92.     case AV_PIX_FMT_YUV444P9:

  93.         colorspace = " C444p9 XYSCSS=444P9";

  94.         break;

  95.     case AV_PIX_FMT_YUV420P10:

  96.         colorspace = " C420p10 XYSCSS=420P10";

  97.         break;

  98.     case AV_PIX_FMT_YUV422P10:

  99.         colorspace = " C422p10 XYSCSS=422P10";

  100.         break;

  101.     case AV_PIX_FMT_YUV444P10:

  102.         colorspace = " C444p10 XYSCSS=444P10";

  103.         break;

  104.     case AV_PIX_FMT_YUV420P12:

  105.         colorspace = " C420p12 XYSCSS=420P12";

  106.         break;

  107.     case AV_PIX_FMT_YUV422P12:

  108.         colorspace = " C422p12 XYSCSS=422P12";

  109.         break;

  110.     case AV_PIX_FMT_YUV444P12:

  111.         colorspace = " C444p12 XYSCSS=444P12";

  112.         break;

  113.     case AV_PIX_FMT_YUV420P14:

  114.         colorspace = " C420p14 XYSCSS=420P14";

  115.         break;

  116.     case AV_PIX_FMT_YUV422P14:

  117.         colorspace = " C422p14 XYSCSS=422P14";

  118.         break;

  119.     case AV_PIX_FMT_YUV444P14:

  120.         colorspace = " C444p14 XYSCSS=444P14";

  121.         break;

  122.     case AV_PIX_FMT_YUV420P16:

  123.         colorspace = " C420p16 XYSCSS=420P16";

  124.         break;

  125.     case AV_PIX_FMT_YUV422P16:

  126.         colorspace = " C422p16 XYSCSS=422P16";

  127.         break;

  128.     case AV_PIX_FMT_YUV444P16:

  129.         colorspace = " C444p16 XYSCSS=444P16";

  130.         break;

  131.     }

  132. 

  133.     /* construct stream header, if this is the first frame */

  134.     n = snprintf(buf, Y4M_LINE_MAX, "%s W%d H%d F%d:%d I%c A%d:%d%s\n",

  135.                  Y4M_MAGIC, width, height, raten, rated, inter,

  136.                  aspectn, aspectd, colorspace);

  137. 

  138.     return n;

  139. }

  140. 

  141. static int yuv4_write_packet(AVFormatContext *s, AVPacket *pkt)

  142. {

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

  144.     AVIOContext *pb = s->pb;

  145.     AVPicture *picture, picture_tmp;

  146.     int* first_pkt = s->priv_data;

  147.     int width, height, h_chroma_shift, v_chroma_shift;

  148.     int i;

  149.     char buf2[Y4M_LINE_MAX + 1];

  150.     char buf1[20];

  151.     uint8_t *ptr, *ptr1, *ptr2;

  152. 

  153.     memcpy(&picture_tmp, pkt->data, sizeof(AVPicture));

  154.     picture = &picture_tmp;

  155. 

  156.     /* for the first packet we have to output the header as well */

  157.     if (*first_pkt) {

  158.         *first_pkt = 0;

  159.         if (yuv4_generate_header(s, buf2) < 0) {

  160.             av_log(s, AV_LOG_ERROR,

  161.                    "Error. YUV4MPEG stream header write failed.\n");

  162.             return AVERROR(EIO);

  163.         } else {

  164.             avio_write(pb, buf2, strlen(buf2));

  165.         }

  166.     }

  167. 

  168.     /* construct frame header */

  169. 

  170.     snprintf(buf1, sizeof(buf1), "%s\n", Y4M_FRAME_MAGIC);

  171.     avio_write(pb, buf1, strlen(buf1));

  172. 

  173.     width  = st->codec->width;

  174.     height = st->codec->height;

  175. 

  176.     ptr = picture->data[0];

  177. 

  178.     switch (st->codec->pix_fmt) {

  179.     case AV_PIX_FMT_GRAY8:

  180.     case AV_PIX_FMT_YUV411P:

  181.     case AV_PIX_FMT_YUV420P:

  182.     case AV_PIX_FMT_YUV422P:

  183.     case AV_PIX_FMT_YUV444P:

  184.         break;

  185.     case AV_PIX_FMT_GRAY16:

  186.     case AV_PIX_FMT_YUV420P9:

  187.     case AV_PIX_FMT_YUV422P9:

  188.     case AV_PIX_FMT_YUV444P9:

  189.     case AV_PIX_FMT_YUV420P10:

  190.     case AV_PIX_FMT_YUV422P10:

  191.     case AV_PIX_FMT_YUV444P10:

  192.     case AV_PIX_FMT_YUV420P12:

  193.     case AV_PIX_FMT_YUV422P12:

  194.     case AV_PIX_FMT_YUV444P12:

  195.     case AV_PIX_FMT_YUV420P14:

  196.     case AV_PIX_FMT_YUV422P14:

  197.     case AV_PIX_FMT_YUV444P14:

  198.     case AV_PIX_FMT_YUV420P16:

  199.     case AV_PIX_FMT_YUV422P16:

  200.     case AV_PIX_FMT_YUV444P16:

  201.         width *= 2;

  202.         break;

  203.     default:

  204.         av_log(s, AV_LOG_ERROR, "The pixel format '%s' is not supported.\n",

  205.                av_get_pix_fmt_name(st->codec->pix_fmt));

  206.         return AVERROR(EINVAL);

  207.     }

  208. 

  209.     for (i = 0; i < height; i++) {

  210.         avio_write(pb, ptr, width);

  211.         ptr += picture->linesize[0];

  212.     }

  213. 

  214.     if (st->codec->pix_fmt != AV_PIX_FMT_GRAY8 &&

  215.         st->codec->pix_fmt != AV_PIX_FMT_GRAY16) {

  216.         // Adjust for smaller Cb and Cr planes

  217.         av_pix_fmt_get_chroma_sub_sample(st->codec->pix_fmt, &h_chroma_shift,

  218.                                          &v_chroma_shift);

  219.         width  = FF_CEIL_RSHIFT(width,  h_chroma_shift);

  220.         height = FF_CEIL_RSHIFT(height, v_chroma_shift);

  221. 

  222.         ptr1 = picture->data[1];

  223.         ptr2 = picture->data[2];

  224.         for (i = 0; i < height; i++) {     /* Cb */

  225.             avio_write(pb, ptr1, width);

  226.             ptr1 += picture->linesize[1];

  227.         }

  228.         for (i = 0; i < height; i++) {     /* Cr */

  229.             avio_write(pb, ptr2, width);

  230.             ptr2 += picture->linesize[2];

  231.         }

  232.     }

  233. 

  234.     return 0;

  235. }

  236. 

  237. static int yuv4_write_header(AVFormatContext *s)

  238. {

  239.     int *first_pkt = s->priv_data;

  240. 

  241.     if (s->nb_streams != 1)

  242.         return AVERROR(EIO);

  243. 

  244.     if (s->streams[0]->codec->codec_id != AV_CODEC_ID_RAWVIDEO) {

  245.         av_log(s, AV_LOG_ERROR, "ERROR: Only rawvideo supported.\n");

  246.         return AVERROR_INVALIDDATA;

  247.     }

  248. 

  249.     switch (s->streams[0]->codec->pix_fmt) {

  250.     case AV_PIX_FMT_YUV411P:

  251.         av_log(s, AV_LOG_WARNING, "Warning: generating rarely used 4:1:1 YUV "

  252.                "stream, some mjpegtools might not work.\n");

  253.         break;

  254.     case AV_PIX_FMT_GRAY8:

  255.     case AV_PIX_FMT_GRAY16:

  256.     case AV_PIX_FMT_YUV420P:

  257.     case AV_PIX_FMT_YUV422P:

  258.     case AV_PIX_FMT_YUV444P:

  259.         break;

  260.     case AV_PIX_FMT_YUV420P9:

  261.     case AV_PIX_FMT_YUV422P9:

  262.     case AV_PIX_FMT_YUV444P9:

  263.     case AV_PIX_FMT_YUV420P10:

  264.     case AV_PIX_FMT_YUV422P10:

  265.     case AV_PIX_FMT_YUV444P10:

  266.     case AV_PIX_FMT_YUV420P12:

  267.     case AV_PIX_FMT_YUV422P12:

  268.     case AV_PIX_FMT_YUV444P12:

  269.     case AV_PIX_FMT_YUV420P14:

  270.     case AV_PIX_FMT_YUV422P14:

  271.     case AV_PIX_FMT_YUV444P14:

  272.     case AV_PIX_FMT_YUV420P16:

  273.     case AV_PIX_FMT_YUV422P16:

  274.     case AV_PIX_FMT_YUV444P16:

  275.         if (s->streams[0]->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {

  276.             av_log(s, AV_LOG_ERROR, "'%s' is not a official yuv4mpegpipe pixel format. "

  277.                    "Use '-strict -1' to encode to this pixel format.\n",

  278.                    av_get_pix_fmt_name(s->streams[0]->codec->pix_fmt));

  279.             return AVERROR(EINVAL);

  280.         }

  281.         av_log(s, AV_LOG_WARNING, "Warning: generating non standard YUV stream. "

  282.                "Mjpegtools will not work.\n");

  283.         break;

  284.     default:

  285.         av_log(s, AV_LOG_ERROR, "ERROR: yuv4mpeg can only handle "

  286.                "yuv444p, yuv422p, yuv420p, yuv411p and gray8 pixel formats. "

  287.                "And using 'strict -1' also yuv444p9, yuv422p9, yuv420p9, "

  288.                "yuv444p10, yuv422p10, yuv420p10, "

  289.                "yuv444p12, yuv422p12, yuv420p12, "

  290.                "yuv444p14, yuv422p14, yuv420p14, "

  291.                "yuv444p16, yuv422p16, yuv420p16 "

  292.                "and gray16 pixel formats. "

  293.                "Use -pix_fmt to select one.\n");

  294.         return AVERROR(EIO);

  295.     }

  296. 

  297.     *first_pkt = 1;

  298.     return 0;

  299. }

  300. 

  301. AVOutputFormat ff_yuv4mpegpipe_muxer = {

  302.     .name              = "yuv4mpegpipe",

  303.     .long_name         = NULL_IF_CONFIG_SMALL("YUV4MPEG pipe"),

  304.     .extensions        = "y4m",

  305.     .priv_data_size    = sizeof(int),

  306.     .audio_codec       = AV_CODEC_ID_NONE,

  307.     .video_codec       = AV_CODEC_ID_RAWVIDEO,

  308.     .write_header      = yuv4_write_header,

  309.     .write_packet      = yuv4_write_packet,

  310.     .flags             = AVFMT_RAWPICTURE,

  311. };

  312. #endif

  313. 

  314. /* Header size increased to allow room for optional flags */

  315. #define MAX_YUV4_HEADER 80

  316. #define MAX_FRAME_HEADER 80

  317. 

  318. static int yuv4_read_header(AVFormatContext *s)

  319. {

  320.     char header[MAX_YUV4_HEADER + 10];  // Include headroom for

  321.                                         // the longest option

  322.     char *tokstart, *tokend, *header_end, interlaced = '?';

  323.     int i;

  324.     AVIOContext *pb = s->pb;

  325.     int width = -1, height  = -1, raten   = 0,

  326.         rated =  0, aspectn =  0, aspectd = 0;

  327.     enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE, alt_pix_fmt = AV_PIX_FMT_NONE;

  328.     enum AVChromaLocation chroma_sample_location = AVCHROMA_LOC_UNSPECIFIED;

  329.     AVStream *st;

  330. 

  331.     for (i = 0; i < MAX_YUV4_HEADER; i++) {

  332.         header[i] = avio_r8(pb);

  333.         if (header[i] == '\n') {

  334.             header[i + 1] = 0x20;  // Add a space after last option.

  335.                                    // Makes parsing "444" vs "444alpha" easier.

  336.             header[i + 2] = 0;

  337.             break;

  338.         }

  339.     }

  340.     if (i == MAX_YUV4_HEADER)

  341.         return -1;

  342.     if (strncmp(header, Y4M_MAGIC, strlen(Y4M_MAGIC)))

  343.         return -1;

  344. 

  345.     header_end = &header[i + 1]; // Include space

  346.     for (tokstart = &header[strlen(Y4M_MAGIC) + 1];

  347.          tokstart < header_end; tokstart++) {

  348.         if (*tokstart == 0x20)

  349.             continue;

  350.         switch (*tokstart++) {

  351.         case 'W': // Width. Required.

  352.             width    = strtol(tokstart, &tokend, 10);

  353.             tokstart = tokend;

  354.             break;

  355.         case 'H': // Height. Required.

  356.             height   = strtol(tokstart, &tokend, 10);

  357.             tokstart = tokend;

  358.             break;

  359.         case 'C': // Color space

  360.             if (strncmp("420jpeg", tokstart, 7) == 0) {

  361.                 pix_fmt = AV_PIX_FMT_YUV420P;

  362.                 chroma_sample_location = AVCHROMA_LOC_CENTER;

  363.             } else if (strncmp("420mpeg2", tokstart, 8) == 0) {

  364.                 pix_fmt = AV_PIX_FMT_YUV420P;

  365.                 chroma_sample_location = AVCHROMA_LOC_LEFT;

  366.             } else if (strncmp("420paldv", tokstart, 8) == 0) {

  367.                 pix_fmt = AV_PIX_FMT_YUV420P;

  368.                 chroma_sample_location = AVCHROMA_LOC_TOPLEFT;

  369.             } else if (strncmp("420p16", tokstart, 6) == 0) {

  370.                 pix_fmt = AV_PIX_FMT_YUV420P16;

  371.             } else if (strncmp("422p16", tokstart, 6) == 0) {

  372.                 pix_fmt = AV_PIX_FMT_YUV422P16;

  373.             } else if (strncmp("444p16", tokstart, 6) == 0) {

  374.                 pix_fmt = AV_PIX_FMT_YUV444P16;

  375.             } else if (strncmp("420p14", tokstart, 6) == 0) {

  376.                 pix_fmt = AV_PIX_FMT_YUV420P14;

  377.             } else if (strncmp("422p14", tokstart, 6) == 0) {

  378.                 pix_fmt = AV_PIX_FMT_YUV422P14;

  379.             } else if (strncmp("444p14", tokstart, 6) == 0) {

  380.                 pix_fmt = AV_PIX_FMT_YUV444P14;

  381.             } else if (strncmp("420p12", tokstart, 6) == 0) {

  382.                 pix_fmt = AV_PIX_FMT_YUV420P12;

  383.             } else if (strncmp("422p12", tokstart, 6) == 0) {

  384.                 pix_fmt = AV_PIX_FMT_YUV422P12;

  385.             } else if (strncmp("444p12", tokstart, 6) == 0) {

  386.                 pix_fmt = AV_PIX_FMT_YUV444P12;

  387.             } else if (strncmp("420p10", tokstart, 6) == 0) {

  388.                 pix_fmt = AV_PIX_FMT_YUV420P10;

  389.             } else if (strncmp("422p10", tokstart, 6) == 0) {

  390.                 pix_fmt = AV_PIX_FMT_YUV422P10;

  391.             } else if (strncmp("444p10", tokstart, 6) == 0) {

  392.                 pix_fmt = AV_PIX_FMT_YUV444P10;

  393.             } else if (strncmp("420p9", tokstart, 5) == 0) {

  394.                 pix_fmt = AV_PIX_FMT_YUV420P9;

  395.             } else if (strncmp("422p9", tokstart, 5) == 0) {

  396.                 pix_fmt = AV_PIX_FMT_YUV422P9;

  397.             } else if (strncmp("444p9", tokstart, 5) == 0) {

  398.                 pix_fmt = AV_PIX_FMT_YUV444P9;

  399.             } else if (strncmp("420", tokstart, 3) == 0) {

  400.                 pix_fmt = AV_PIX_FMT_YUV420P;

  401.                 chroma_sample_location = AVCHROMA_LOC_CENTER;

  402.             } else if (strncmp("411", tokstart, 3) == 0) {

  403.                 pix_fmt = AV_PIX_FMT_YUV411P;

  404.             } else if (strncmp("422", tokstart, 3) == 0) {

  405.                 pix_fmt = AV_PIX_FMT_YUV422P;

  406.             } else if (strncmp("444alpha", tokstart, 8) == 0 ) {

  407.                 av_log(s, AV_LOG_ERROR, "Cannot handle 4:4:4:4 "

  408.                        "YUV4MPEG stream.\n");

  409.                 return -1;

  410.             } else if (strncmp("444", tokstart, 3) == 0) {

  411.                 pix_fmt = AV_PIX_FMT_YUV444P;

  412.             } else if (strncmp("mono16", tokstart, 6) == 0) {

  413.                 pix_fmt = AV_PIX_FMT_GRAY16;

  414.             } else if (strncmp("mono", tokstart, 4) == 0) {

  415.                 pix_fmt = AV_PIX_FMT_GRAY8;

  416.             } else {

  417.                 av_log(s, AV_LOG_ERROR, "YUV4MPEG stream contains an unknown "

  418.                        "pixel format.\n");

  419.                 return -1;

  420.             }

  421.             while (tokstart < header_end && *tokstart != 0x20)

  422.                 tokstart++;

  423.             break;

  424.         case 'I': // Interlace type

  425.             interlaced = *tokstart++;

  426.             break;

  427.         case 'F': // Frame rate

  428.             sscanf(tokstart, "%d:%d", &raten, &rated); // 0:0 if unknown

  429.             while (tokstart < header_end && *tokstart != 0x20)

  430.                 tokstart++;

  431.             break;

  432.         case 'A': // Pixel aspect

  433.             sscanf(tokstart, "%d:%d", &aspectn, &aspectd); // 0:0 if unknown

  434.             while (tokstart < header_end && *tokstart != 0x20)

  435.                 tokstart++;

  436.             break;

  437.         case 'X': // Vendor extensions

  438.             if (strncmp("YSCSS=", tokstart, 6) == 0) {

  439.                 // Older nonstandard pixel format representation

  440.                 tokstart += 6;

  441.                 if (strncmp("420JPEG", tokstart, 7) == 0)

  442.                     alt_pix_fmt = AV_PIX_FMT_YUV420P;

  443.                 else if (strncmp("420MPEG2", tokstart, 8) == 0)

  444.                     alt_pix_fmt = AV_PIX_FMT_YUV420P;

  445.                 else if (strncmp("420PALDV", tokstart, 8) == 0)

  446.                     alt_pix_fmt = AV_PIX_FMT_YUV420P;

  447.                 else if (strncmp("420P9", tokstart, 5) == 0)

  448.                     alt_pix_fmt = AV_PIX_FMT_YUV420P9;

  449.                 else if (strncmp("422P9", tokstart, 5) == 0)

  450.                     alt_pix_fmt = AV_PIX_FMT_YUV422P9;

  451.                 else if (strncmp("444P9", tokstart, 5) == 0)

  452.                     alt_pix_fmt = AV_PIX_FMT_YUV444P9;

  453.                 else if (strncmp("420P10", tokstart, 6) == 0)

  454.                     alt_pix_fmt = AV_PIX_FMT_YUV420P10;

  455.                 else if (strncmp("422P10", tokstart, 6) == 0)

  456.                     alt_pix_fmt = AV_PIX_FMT_YUV422P10;

  457.                 else if (strncmp("444P10", tokstart, 6) == 0)

  458.                     alt_pix_fmt = AV_PIX_FMT_YUV444P10;

  459.                 else if (strncmp("420P12", tokstart, 6) == 0)

  460.                     alt_pix_fmt = AV_PIX_FMT_YUV420P12;

  461.                 else if (strncmp("422P12", tokstart, 6) == 0)

  462.                     alt_pix_fmt = AV_PIX_FMT_YUV422P12;

  463.                 else if (strncmp("444P12", tokstart, 6) == 0)

  464.                     alt_pix_fmt = AV_PIX_FMT_YUV444P12;

  465.                 else if (strncmp("420P14", tokstart, 6) == 0)

  466.                     alt_pix_fmt = AV_PIX_FMT_YUV420P14;

  467.                 else if (strncmp("422P14", tokstart, 6) == 0)

  468.                     alt_pix_fmt = AV_PIX_FMT_YUV422P14;

  469.                 else if (strncmp("444P14", tokstart, 6) == 0)

  470.                     alt_pix_fmt = AV_PIX_FMT_YUV444P14;

  471.                 else if (strncmp("420P16", tokstart, 6) == 0)

  472.                     alt_pix_fmt = AV_PIX_FMT_YUV420P16;

  473.                 else if (strncmp("422P16", tokstart, 6) == 0)

  474.                     alt_pix_fmt = AV_PIX_FMT_YUV422P16;

  475.                 else if (strncmp("444P16", tokstart, 6) == 0)

  476.                     alt_pix_fmt = AV_PIX_FMT_YUV444P16;

  477.                 else if (strncmp("411", tokstart, 3) == 0)

  478.                     alt_pix_fmt = AV_PIX_FMT_YUV411P;

  479.                 else if (strncmp("422", tokstart, 3) == 0)

  480.                     alt_pix_fmt = AV_PIX_FMT_YUV422P;

  481.                 else if (strncmp("444", tokstart, 3) == 0)

  482.                     alt_pix_fmt = AV_PIX_FMT_YUV444P;

  483.             }

  484.             while (tokstart < header_end && *tokstart != 0x20)

  485.                 tokstart++;

  486.             break;

  487.         }

  488.     }

  489. 

  490.     if (width == -1 || height == -1) {

  491.         av_log(s, AV_LOG_ERROR, "YUV4MPEG has invalid header.\n");

  492.         return -1;

  493.     }

  494. 

  495.     if (pix_fmt == AV_PIX_FMT_NONE) {

  496.         if (alt_pix_fmt == AV_PIX_FMT_NONE)

  497.             pix_fmt = AV_PIX_FMT_YUV420P;

  498.         else

  499.             pix_fmt = alt_pix_fmt;

  500.     }

  501. 

  502.     if (raten <= 0 || rated <= 0) {

  503.         // Frame rate unknown

  504.         raten = 25;

  505.         rated = 1;

  506.     }

  507. 

  508.     if (aspectn == 0 && aspectd == 0) {

  509.         // Pixel aspect unknown

  510.         aspectd = 1;

  511.     }

  512. 

  513.     st = avformat_new_stream(s, NULL);

  514.     if (!st)

  515.         return AVERROR(ENOMEM);

  516.     st->codec->width  = width;

  517.     st->codec->height = height;

  518.     av_reduce(&raten, &rated, raten, rated, (1UL << 31) - 1);

  519.     avpriv_set_pts_info(st, 64, rated, raten);

  520.     st->avg_frame_rate                = av_inv_q(st->time_base);

  521.     st->codec->pix_fmt                = pix_fmt;

  522.     st->codec->codec_type             = AVMEDIA_TYPE_VIDEO;

  523.     st->codec->codec_id               = AV_CODEC_ID_RAWVIDEO;

  524.     st->sample_aspect_ratio           = (AVRational){ aspectn, aspectd };

  525.     st->codec->chroma_sample_location = chroma_sample_location;

  526. 

  527.     switch (interlaced){

  528.     case 'p':

  529.         st->codec->field_order = AV_FIELD_PROGRESSIVE;

  530.         break;

  531.     case 't':

  532.         st->codec->field_order = AV_FIELD_TB;

  533.         break;

  534.     case 'b':

  535.         st->codec->field_order = AV_FIELD_BT;

  536.         break;

  537.     case 'm':

  538.         av_log(s, AV_LOG_ERROR, "YUV4MPEG stream contains mixed "

  539.                "interlaced and non-interlaced frames.\n");

  540.     case '?':

  541.         st->codec->field_order = AV_FIELD_UNKNOWN;

  542.         break;

  543.     default:

  544.         av_log(s, AV_LOG_ERROR, "YUV4MPEG has invalid header.\n");

  545.         return AVERROR(EINVAL);

  546.     }

  547. 

  548.     return 0;

  549. }

  550. 

  551. static int yuv4_read_packet(AVFormatContext *s, AVPacket *pkt)

  552. {

  553.     int i;

  554.     char header[MAX_FRAME_HEADER+1];

  555.     int packet_size, width, height, ret;

  556.     AVStream *st = s->streams[0];

  557. 

  558.     for (i = 0; i < MAX_FRAME_HEADER; i++) {

  559.         header[i] = avio_r8(s->pb);

  560.         if (header[i] == '\n') {

  561.             header[i + 1] = 0;

  562.             break;

  563.         }

  564.     }

  565.     if (s->pb->error)

  566.         return s->pb->error;

  567.     else if (s->pb->eof_reached)

  568.         return AVERROR_EOF;

  569.     else if (i == MAX_FRAME_HEADER)

  570.         return AVERROR_INVALIDDATA;

  571. 

  572.     if (strncmp(header, Y4M_FRAME_MAGIC, strlen(Y4M_FRAME_MAGIC)))

  573.         return AVERROR_INVALIDDATA;

  574. 

  575.     width  = st->codec->width;

  576.     height = st->codec->height;

  577. 

  578.     packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);

  579.     if (packet_size < 0)

  580.         return packet_size;

  581. 

  582.     ret = av_get_packet(s->pb, pkt, packet_size);

  583.     if (ret < 0)

  584.         return ret;

  585.     else if (ret != packet_size)

  586.         return s->pb->eof_reached ? AVERROR_EOF : AVERROR(EIO);

  587. 

  588.     pkt->stream_index = 0;

  589.     return 0;

  590. }

  591. 

  592. static int yuv4_probe(AVProbeData *pd)

  593. {

  594.     /* check file header */

  595.     if (strncmp(pd->buf, Y4M_MAGIC, sizeof(Y4M_MAGIC) - 1) == 0)

  596.         return AVPROBE_SCORE_MAX;

  597.     else

  598.         return 0;

  599. }

  600. 

  601. #if CONFIG_YUV4MPEGPIPE_DEMUXER

  602. AVInputFormat ff_yuv4mpegpipe_demuxer = {

  603.     .name           = "yuv4mpegpipe",

  604.     .long_name      = NULL_IF_CONFIG_SMALL("YUV4MPEG pipe"),

  605.     .read_probe     = yuv4_probe,

  606.     .read_header    = yuv4_read_header,

  607.     .read_packet    = yuv4_read_packet,

  608.     .extensions     = "y4m",

  609. };

  610. #endif