LCOV - code coverage report
Current view: top level - libavcodec - h264_sei.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 151 287 52.6 %
Date: 2017-12-18 06:23:41 Functions: 9 14 64.3 %

          Line data    Source code
       1             : /*
       2             :  * H.26L/H.264/AVC/JVT/14496-10/... SEI decoding
       3             :  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
       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             : /**
      23             :  * @file
      24             :  * H.264 / AVC / MPEG-4 part10 SEI decoding.
      25             :  * @author Michael Niedermayer <michaelni@gmx.at>
      26             :  */
      27             : 
      28             : #include "avcodec.h"
      29             : #include "get_bits.h"
      30             : #include "golomb.h"
      31             : #include "h264_ps.h"
      32             : #include "h264_sei.h"
      33             : #include "internal.h"
      34             : 
      35             : #define AVERROR_PS_NOT_FOUND      FFERRTAG(0xF8,'?','P','S')
      36             : 
      37             : static const uint8_t sei_num_clock_ts_table[9] = {
      38             :     1, 1, 1, 2, 2, 3, 3, 2, 3
      39             : };
      40             : 
      41       52326 : void ff_h264_sei_uninit(H264SEIContext *h)
      42             : {
      43       52326 :     h->recovery_point.recovery_frame_cnt = -1;
      44             : 
      45       52326 :     h->picture_timing.dpb_output_delay  = 0;
      46       52326 :     h->picture_timing.cpb_removal_delay = -1;
      47             : 
      48       52326 :     h->picture_timing.present      = 0;
      49       52326 :     h->buffering_period.present    = 0;
      50       52326 :     h->frame_packing.present       = 0;
      51       52326 :     h->display_orientation.present = 0;
      52       52326 :     h->afd.present                 =  0;
      53             : 
      54       52326 :     h->a53_caption.a53_caption_size = 0;
      55       52326 :     av_freep(&h->a53_caption.a53_caption);
      56       52326 : }
      57             : 
      58        2395 : static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb,
      59             :                                  const H264ParamSets *ps, void *logctx)
      60             : {
      61             :     int i;
      62        2395 :     const SPS *sps = ps->sps;
      63             : 
      64       79035 :     for (i = 0; i<MAX_SPS_COUNT; i++)
      65       76640 :         if ((!sps || !sps->log2_max_frame_num) && ps->sps_list[i])
      66          65 :             sps = (const SPS *)ps->sps_list[i]->data;
      67             : 
      68        2395 :     if (!sps) {
      69          52 :         av_log(logctx, AV_LOG_ERROR, "SPS unavailable in decode_picture_timing\n");
      70          52 :         return AVERROR_PS_NOT_FOUND;
      71             :     }
      72             : 
      73        3165 :     if (sps->nal_hrd_parameters_present_flag ||
      74         822 :         sps->vcl_hrd_parameters_present_flag) {
      75        1521 :         h->cpb_removal_delay = get_bits_long(gb, sps->cpb_removal_delay_length);
      76        1521 :         h->dpb_output_delay  = get_bits_long(gb, sps->dpb_output_delay_length);
      77             :     }
      78        2343 :     if (sps->pic_struct_present_flag) {
      79             :         unsigned int i, num_clock_ts;
      80             : 
      81        2321 :         h->pic_struct = get_bits(gb, 4);
      82        2321 :         h->ct_type    = 0;
      83             : 
      84        2321 :         if (h->pic_struct > H264_SEI_PIC_STRUCT_FRAME_TRIPLING)
      85           0 :             return AVERROR_INVALIDDATA;
      86             : 
      87        2321 :         num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
      88             : 
      89        5373 :         for (i = 0; i < num_clock_ts; i++) {
      90        3052 :             if (get_bits(gb, 1)) {                /* clock_timestamp_flag */
      91             :                 unsigned int full_timestamp_flag;
      92             : 
      93         702 :                 h->ct_type |= 1 << get_bits(gb, 2);
      94         702 :                 skip_bits(gb, 1);                 /* nuit_field_based_flag */
      95         702 :                 skip_bits(gb, 5);                 /* counting_type */
      96         702 :                 full_timestamp_flag = get_bits(gb, 1);
      97         702 :                 skip_bits(gb, 1);                 /* discontinuity_flag */
      98         702 :                 skip_bits(gb, 1);                 /* cnt_dropped_flag */
      99         702 :                 skip_bits(gb, 8);                 /* n_frames */
     100         702 :                 if (full_timestamp_flag) {
     101           0 :                     skip_bits(gb, 6);             /* seconds_value 0..59 */
     102           0 :                     skip_bits(gb, 6);             /* minutes_value 0..59 */
     103           0 :                     skip_bits(gb, 5);             /* hours_value 0..23 */
     104             :                 } else {
     105         702 :                     if (get_bits(gb, 1)) {        /* seconds_flag */
     106         339 :                         skip_bits(gb, 6);         /* seconds_value range 0..59 */
     107         339 :                         if (get_bits(gb, 1)) {    /* minutes_flag */
     108         327 :                             skip_bits(gb, 6);     /* minutes_value 0..59 */
     109         327 :                             if (get_bits(gb, 1))  /* hours_flag */
     110           0 :                                 skip_bits(gb, 5); /* hours_value 0..23 */
     111             :                         }
     112             :                     }
     113             :                 }
     114         702 :                 if (sps->time_offset_length > 0)
     115         702 :                     skip_bits(gb,
     116             :                               sps->time_offset_length); /* time_offset */
     117             :             }
     118             :         }
     119             : 
     120        2321 :         av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
     121        2321 :                h->ct_type, h->pic_struct);
     122             :     }
     123             : 
     124        2343 :     h->present = 1;
     125        2343 :     return 0;
     126             : }
     127             : 
     128         639 : static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size)
     129             : {
     130             :     int flag;
     131             : 
     132         639 :     if (size-- < 1)
     133           0 :         return AVERROR_INVALIDDATA;
     134         639 :     skip_bits(gb, 1);               // 0
     135         639 :     flag = get_bits(gb, 1);         // active_format_flag
     136         639 :     skip_bits(gb, 6);               // reserved
     137             : 
     138         639 :     if (flag) {
     139         639 :         if (size-- < 1)
     140           0 :             return AVERROR_INVALIDDATA;
     141         639 :         skip_bits(gb, 4);           // reserved
     142         639 :         h->active_format_description = get_bits(gb, 4);
     143         639 :         h->present                   = 1;
     144             :     }
     145             : 
     146         639 :     return 0;
     147             : }
     148             : 
     149           0 : static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h,
     150             :                                                      GetBitContext *gb, void *logctx,
     151             :                                                      int size)
     152             : {
     153             :     int flag;
     154             :     int user_data_type_code;
     155             :     int cc_count;
     156             : 
     157           0 :     if (size < 3)
     158           0 :         return AVERROR(EINVAL);
     159             : 
     160           0 :     user_data_type_code = get_bits(gb, 8);
     161           0 :     if (user_data_type_code == 0x3) {
     162           0 :         skip_bits(gb, 1);           // reserved
     163             : 
     164           0 :         flag = get_bits(gb, 1);     // process_cc_data_flag
     165           0 :         if (flag) {
     166           0 :             skip_bits(gb, 1);       // zero bit
     167           0 :             cc_count = get_bits(gb, 5);
     168           0 :             skip_bits(gb, 8);       // reserved
     169           0 :             size -= 2;
     170             : 
     171           0 :             if (cc_count && size >= cc_count * 3) {
     172           0 :                 const uint64_t new_size = (h->a53_caption_size + cc_count
     173           0 :                                            * UINT64_C(3));
     174             :                 int i, ret;
     175             : 
     176           0 :                 if (new_size > INT_MAX)
     177           0 :                     return AVERROR(EINVAL);
     178             : 
     179             :                 /* Allow merging of the cc data from two fields. */
     180           0 :                 ret = av_reallocp(&h->a53_caption, new_size);
     181           0 :                 if (ret < 0)
     182           0 :                     return ret;
     183             : 
     184           0 :                 for (i = 0; i < cc_count; i++) {
     185           0 :                     h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
     186           0 :                     h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
     187           0 :                     h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
     188             :                 }
     189             : 
     190           0 :                 skip_bits(gb, 8);   // marker_bits
     191             :             }
     192             :         }
     193             :     } else {
     194             :         int i;
     195           0 :         for (i = 0; i < size - 1; i++)
     196           0 :             skip_bits(gb, 8);
     197             :     }
     198             : 
     199           0 :     return 0;
     200             : }
     201             : 
     202         639 : static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb,
     203             :                                        void *logctx, int size)
     204             : {
     205             :     uint32_t country_code;
     206             :     uint32_t user_identifier;
     207             : 
     208         639 :     if (size < 7)
     209           0 :         return AVERROR_INVALIDDATA;
     210         639 :     size -= 7;
     211             : 
     212         639 :     country_code = get_bits(gb, 8); // itu_t_t35_country_code
     213         639 :     if (country_code == 0xFF) {
     214           0 :         skip_bits(gb, 8);           // itu_t_t35_country_code_extension_byte
     215           0 :         size--;
     216             :     }
     217             : 
     218             :     /* itu_t_t35_payload_byte follows */
     219         639 :     skip_bits(gb, 8);              // terminal provider code
     220         639 :     skip_bits(gb, 8);              // terminal provider oriented code
     221         639 :     user_identifier = get_bits_long(gb, 32);
     222             : 
     223         639 :     switch (user_identifier) {
     224         639 :         case MKBETAG('D', 'T', 'G', '1'):       // afd_data
     225         639 :             return decode_registered_user_data_afd(&h->afd, gb, size);
     226           0 :         case MKBETAG('G', 'A', '9', '4'):       // closed captions
     227           0 :             return decode_registered_user_data_closed_caption(&h->a53_caption, gb,
     228             :                                                               logctx, size);
     229           0 :         default:
     230           0 :             skip_bits(gb, size * 8);
     231           0 :             break;
     232             :     }
     233             : 
     234           0 :     return 0;
     235             : }
     236             : 
     237         239 : static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb,
     238             :                                          void *logctx, int size)
     239             : {
     240             :     uint8_t *user_data;
     241             :     int e, build, i;
     242             : 
     243         239 :     if (size < 16 || size >= INT_MAX - 16)
     244           0 :         return AVERROR_INVALIDDATA;
     245             : 
     246         239 :     user_data = av_malloc(16 + size + 1);
     247         239 :     if (!user_data)
     248           0 :         return AVERROR(ENOMEM);
     249             : 
     250       48813 :     for (i = 0; i < size + 16; i++)
     251       48574 :         user_data[i] = get_bits(gb, 8);
     252             : 
     253         239 :     user_data[i] = 0;
     254         239 :     e = sscanf(user_data + 16, "x264 - core %d", &build);
     255         239 :     if (e == 1 && build > 0)
     256          66 :         h->x264_build = build;
     257         239 :     if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
     258           0 :         h->x264_build = 67;
     259             : 
     260         239 :     av_free(user_data);
     261         239 :     return 0;
     262             : }
     263             : 
     264          53 : static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb)
     265             : {
     266          53 :     h->recovery_frame_cnt = get_ue_golomb_long(gb);
     267             : 
     268             :     /* 1b exact_match_flag,
     269             :      * 1b broken_link_flag,
     270             :      * 2b changing_slice_group_idc */
     271          53 :     skip_bits(gb, 4);
     272             : 
     273          53 :     return 0;
     274             : }
     275             : 
     276         677 : static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb,
     277             :                                    const H264ParamSets *ps, void *logctx)
     278             : {
     279             :     unsigned int sps_id;
     280             :     int sched_sel_idx;
     281             :     const SPS *sps;
     282             : 
     283         677 :     sps_id = get_ue_golomb_31(gb);
     284         677 :     if (sps_id > 31 || !ps->sps_list[sps_id]) {
     285           4 :         av_log(logctx, AV_LOG_ERROR,
     286             :                "non-existing SPS %d referenced in buffering period\n", sps_id);
     287           4 :         return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
     288             :     }
     289         673 :     sps = (const SPS*)ps->sps_list[sps_id]->data;
     290             : 
     291             :     // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
     292         673 :     if (sps->nal_hrd_parameters_present_flag) {
     293         468 :         for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
     294         234 :             h->initial_cpb_removal_delay[sched_sel_idx] =
     295         234 :                 get_bits_long(gb, sps->initial_cpb_removal_delay_length);
     296             :             // initial_cpb_removal_delay_offset
     297         234 :             skip_bits(gb, sps->initial_cpb_removal_delay_length);
     298             :         }
     299             :     }
     300         673 :     if (sps->vcl_hrd_parameters_present_flag) {
     301         360 :         for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
     302         180 :             h->initial_cpb_removal_delay[sched_sel_idx] =
     303         180 :                 get_bits_long(gb, sps->initial_cpb_removal_delay_length);
     304             :             // initial_cpb_removal_delay_offset
     305         180 :             skip_bits(gb, sps->initial_cpb_removal_delay_length);
     306             :         }
     307             :     }
     308             : 
     309         673 :     h->present = 1;
     310         673 :     return 0;
     311             : }
     312             : 
     313           0 : static int decode_frame_packing_arrangement(H264SEIFramePacking *h,
     314             :                                             GetBitContext *gb)
     315             : {
     316           0 :     h->arrangement_id          = get_ue_golomb_long(gb);
     317           0 :     h->arrangement_cancel_flag = get_bits1(gb);
     318           0 :     h->present = !h->arrangement_cancel_flag;
     319             : 
     320           0 :     if (h->present) {
     321           0 :         h->arrangement_type = get_bits(gb, 7);
     322           0 :         h->quincunx_sampling_flag         = get_bits1(gb);
     323           0 :         h->content_interpretation_type    = get_bits(gb, 6);
     324             : 
     325             :         // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
     326           0 :         skip_bits(gb, 3);
     327           0 :         h->current_frame_is_frame0_flag = get_bits1(gb);
     328             :         // frame0_self_contained_flag, frame1_self_contained_flag
     329           0 :         skip_bits(gb, 2);
     330             : 
     331           0 :         if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
     332           0 :             skip_bits(gb, 16);      // frame[01]_grid_position_[xy]
     333           0 :         skip_bits(gb, 8);           // frame_packing_arrangement_reserved_byte
     334           0 :         h->arrangement_repetition_period = get_ue_golomb_long(gb);
     335             :     }
     336           0 :     skip_bits1(gb);                 // frame_packing_arrangement_extension_flag
     337             : 
     338           0 :     return 0;
     339             : }
     340             : 
     341           0 : static int decode_display_orientation(H264SEIDisplayOrientation *h,
     342             :                                       GetBitContext *gb)
     343             : {
     344           0 :     h->present = !get_bits1(gb);
     345             : 
     346           0 :     if (h->present) {
     347           0 :         h->hflip = get_bits1(gb);     // hor_flip
     348           0 :         h->vflip = get_bits1(gb);     // ver_flip
     349             : 
     350           0 :         h->anticlockwise_rotation = get_bits(gb, 16);
     351           0 :         get_ue_golomb_long(gb);       // display_orientation_repetition_period
     352           0 :         skip_bits1(gb);               // display_orientation_extension_flag
     353             :     }
     354             : 
     355           0 :     return 0;
     356             : }
     357             : 
     358           0 : static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
     359             : {
     360           0 :     h->green_metadata_type = get_bits(gb, 8);
     361             : 
     362           0 :     if (h->green_metadata_type == 0) {
     363           0 :         h->period_type = get_bits(gb, 8);
     364             : 
     365           0 :         if (h->period_type == 2)
     366           0 :             h->num_seconds = get_bits(gb, 16);
     367           0 :         else if (h->period_type == 3)
     368           0 :             h->num_pictures = get_bits(gb, 16);
     369             : 
     370           0 :         h->percent_non_zero_macroblocks            = get_bits(gb, 8);
     371           0 :         h->percent_intra_coded_macroblocks         = get_bits(gb, 8);
     372           0 :         h->percent_six_tap_filtering               = get_bits(gb, 8);
     373           0 :         h->percent_alpha_point_deblocking_instance = get_bits(gb, 8);
     374             : 
     375           0 :     } else if (h->green_metadata_type == 1) {
     376           0 :         h->xsd_metric_type  = get_bits(gb, 8);
     377           0 :         h->xsd_metric_value = get_bits(gb, 16);
     378             :     }
     379             : 
     380           0 :     return 0;
     381             : }
     382             : 
     383           0 : static int decode_alternative_transfer(H264SEIAlternativeTransfer *h,
     384             :                                        GetBitContext *gb)
     385             : {
     386           0 :     h->present = 1;
     387           0 :     h->preferred_transfer_characteristics = get_bits(gb, 8);
     388           0 :     return 0;
     389             : }
     390             : 
     391        2955 : int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
     392             :                        const H264ParamSets *ps, void *logctx)
     393             : {
     394        2955 :     int master_ret = 0;
     395             : 
     396       10150 :     while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
     397        4247 :         int type = 0;
     398        4247 :         unsigned size = 0;
     399             :         unsigned next;
     400        4247 :         int ret  = 0;
     401             : 
     402             :         do {
     403        4247 :             if (get_bits_left(gb) < 8)
     404           0 :                 return AVERROR_INVALIDDATA;
     405        4247 :             type += show_bits(gb, 8);
     406        4247 :         } while (get_bits(gb, 8) == 255);
     407             : 
     408             :         do {
     409        4376 :             if (get_bits_left(gb) < 8)
     410           0 :                 return AVERROR_INVALIDDATA;
     411        4376 :             size += show_bits(gb, 8);
     412        4376 :         } while (get_bits(gb, 8) == 255);
     413             : 
     414        4247 :         if (size > get_bits_left(gb) / 8) {
     415           7 :             av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
     416             :                    type, 8*size, get_bits_left(gb));
     417           7 :             return AVERROR_INVALIDDATA;
     418             :         }
     419        4240 :         next = get_bits_count(gb) + 8 * size;
     420             : 
     421        4240 :         switch (type) {
     422        2395 :         case H264_SEI_TYPE_PIC_TIMING: // Picture timing SEI
     423        2395 :             ret = decode_picture_timing(&h->picture_timing, gb, ps, logctx);
     424        2395 :             break;
     425         639 :         case H264_SEI_TYPE_USER_DATA_REGISTERED:
     426         639 :             ret = decode_registered_user_data(h, gb, logctx, size);
     427         639 :             break;
     428         239 :         case H264_SEI_TYPE_USER_DATA_UNREGISTERED:
     429         239 :             ret = decode_unregistered_user_data(&h->unregistered, gb, logctx, size);
     430         239 :             break;
     431          53 :         case H264_SEI_TYPE_RECOVERY_POINT:
     432          53 :             ret = decode_recovery_point(&h->recovery_point, gb);
     433          53 :             break;
     434         677 :         case H264_SEI_TYPE_BUFFERING_PERIOD:
     435         677 :             ret = decode_buffering_period(&h->buffering_period, gb, ps, logctx);
     436         677 :             break;
     437           0 :         case H264_SEI_TYPE_FRAME_PACKING:
     438           0 :             ret = decode_frame_packing_arrangement(&h->frame_packing, gb);
     439           0 :             break;
     440           0 :         case H264_SEI_TYPE_DISPLAY_ORIENTATION:
     441           0 :             ret = decode_display_orientation(&h->display_orientation, gb);
     442           0 :             break;
     443           0 :         case H264_SEI_TYPE_GREEN_METADATA:
     444           0 :             ret = decode_green_metadata(&h->green_metadata, gb);
     445           0 :             break;
     446           0 :         case H264_SEI_TYPE_ALTERNATIVE_TRANSFER:
     447           0 :             ret = decode_alternative_transfer(&h->alternative_transfer, gb);
     448           0 :             break;
     449         237 :         default:
     450         237 :             av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
     451             :         }
     452        4240 :         if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
     453           0 :             return ret;
     454        4240 :         if (ret < 0)
     455          56 :             master_ret = ret;
     456             : 
     457        4240 :         skip_bits_long(gb, next - get_bits_count(gb));
     458             : 
     459             :         // FIXME check bits here
     460        4240 :         align_get_bits(gb);
     461             :     }
     462             : 
     463        2948 :     return master_ret;
     464             : }
     465             : 
     466       21358 : const char *ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
     467             : {
     468       21358 :     if (h->arrangement_cancel_flag == 0) {
     469           0 :         switch (h->arrangement_type) {
     470           0 :             case H264_SEI_FPA_TYPE_CHECKERBOARD:
     471           0 :                 if (h->content_interpretation_type == 2)
     472           0 :                     return "checkerboard_rl";
     473             :                 else
     474           0 :                     return "checkerboard_lr";
     475           0 :             case H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN:
     476           0 :                 if (h->content_interpretation_type == 2)
     477           0 :                     return "col_interleaved_rl";
     478             :                 else
     479           0 :                     return "col_interleaved_lr";
     480           0 :             case H264_SEI_FPA_TYPE_INTERLEAVE_ROW:
     481           0 :                 if (h->content_interpretation_type == 2)
     482           0 :                     return "row_interleaved_rl";
     483             :                 else
     484           0 :                     return "row_interleaved_lr";
     485           0 :             case H264_SEI_FPA_TYPE_SIDE_BY_SIDE:
     486           0 :                 if (h->content_interpretation_type == 2)
     487           0 :                     return "right_left";
     488             :                 else
     489           0 :                     return "left_right";
     490           0 :             case H264_SEI_FPA_TYPE_TOP_BOTTOM:
     491           0 :                 if (h->content_interpretation_type == 2)
     492           0 :                     return "bottom_top";
     493             :                 else
     494           0 :                     return "top_bottom";
     495           0 :             case H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL:
     496           0 :                 if (h->content_interpretation_type == 2)
     497           0 :                     return "block_rl";
     498             :                 else
     499           0 :                     return "block_lr";
     500           0 :             case H264_SEI_FPA_TYPE_2D:
     501             :             default:
     502           0 :                 return "mono";
     503             :         }
     504       21358 :     } else if (h->arrangement_cancel_flag == 1) {
     505           0 :         return "mono";
     506             :     } else {
     507       21358 :         return NULL;
     508             :     }
     509             : }

Generated by: LCOV version 1.13