src/mm_player_utils.c

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
   7  * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28 #include <sys/time.h>
  29 #include <netinet/in.h>
  30 #include <arpa/inet.h>
  31 #include <unicode/ucsdet.h>
  32 #include <dlog.h>
  33 #include <storage.h>
  34 #include <tzplatform_config.h>
  35 #include "mm_player_utils.h"
  36 #include "media_format.h"
  37
  38 #define MEDIA_PATH_EXTERNAL tzplatform_getenv(TZ_SYS_STORAGE) /* external storage, sd card, usb */
  39
  40 const gchar *
  41 _mmplayer_get_stream_type_name(int type)
  42 {
  43         switch (type) {
  44         case MM_PLAYER_STREAM_TYPE_AUDIO:
  45                 return "AUDIO";
  46         case MM_PLAYER_STREAM_TYPE_VIDEO:
  47                 return "VIDEO";
  48         case MM_PLAYER_STREAM_TYPE_TEXT:
  49                 return "TEXT";
  50         case MM_PLAYER_STREAM_TYPE_DEFAULT: /* fall through */
  51         case MM_PLAYER_STREAM_TYPE_MAX:     /* fall through */
  52         default:
  53                 return "INVAID";
  54         }
  55 }
  56
  57 const gchar *
  58 _mmplayer_get_state_name(int state)
  59 {
  60         switch (state) {
  61         case MM_PLAYER_STATE_NULL:
  62                 return "NULL";
  63         case MM_PLAYER_STATE_READY:
  64                 return "READY";
  65         case MM_PLAYER_STATE_PAUSED:
  66                 return "PAUSED";
  67         case MM_PLAYER_STATE_PLAYING:
  68                 return "PLAYING";
  69         case MM_PLAYER_STATE_NONE:
  70                 return "NONE";
  71         default:
  72                 return "INVAID";
  73         }
  74 }
  75
  76 gboolean
  77 _mmplayer_is_rtsp_streaming(mmplayer_t *player)
  78 {
  79         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
  80
  81         return (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_RTSP) ? TRUE : FALSE;
  82 }
  83
  84 gboolean
  85 _mmplayer_is_http_streaming(mmplayer_t *player)
  86 {
  87         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
  88
  89         return (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_HTTP) ? TRUE : FALSE;
  90 }
  91
  92 gboolean
  93 _mmplayer_is_streaming(mmplayer_t *player)
  94 {
  95         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
  96
  97         return (_mmplayer_is_rtsp_streaming(player) || _mmplayer_is_http_streaming(player)
  98                 || _mmplayer_is_http_live_streaming(player) || _mmplayer_is_dash_streaming(player)
  99                 || _mmplayer_is_smooth_streaming(player)) ? TRUE : FALSE;
 100 }
 101
 102 gboolean
 103 _mmplayer_is_live_streaming(mmplayer_t *player)
 104 {
 105         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 106
 107         return (_mmplayer_is_rtsp_streaming(player) && player->streaming_type == STREAMING_SERVICE_LIVE) ? TRUE : FALSE;
 108 }
 109
 110 gboolean
 111 _mmplayer_is_http_live_streaming(mmplayer_t *player)
 112 {
 113         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 114
 115         return (player->profile.uri_type == MM_PLAYER_URI_TYPE_HLS) ? TRUE : FALSE;
 116 }
 117
 118 gboolean
 119 _mmplayer_is_dash_streaming(mmplayer_t *player)
 120 {
 121         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 122
 123         return (player->profile.uri_type == MM_PLAYER_URI_TYPE_DASH) ? TRUE : FALSE;
 124 }
 125
 126 gboolean
 127 _mmplayer_is_smooth_streaming(mmplayer_t *player)
 128 {
 129         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 130
 131         return (player->profile.uri_type == MM_PLAYER_URI_TYPE_SS) ? TRUE : FALSE;
 132 }
 133
 134 gboolean
 135 _mmplayer_is_ms_buff_src(mmplayer_t *player)
 136 {
 137         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 138
 139         return (player->profile.uri_type == MM_PLAYER_URI_TYPE_MS_BUFF) ? TRUE : FALSE;
 140 }
 141
 142 gboolean
 143 _mmplayer_has_suffix(mmplayer_t *player, const gchar *suffix)
 144 {
 145         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 146         MMPLAYER_RETURN_VAL_IF_FAIL(suffix, FALSE);
 147
 148         gboolean ret = FALSE;
 149         gchar *t_url = g_ascii_strdown(player->profile.uri, -1);
 150         gchar *t_suffix = g_ascii_strdown(suffix, -1);
 151         gchar *opt = strchr(t_url, '?');
 152
 153         if (opt)
 154                 *opt = '\0';
 155
 156         ret = g_str_has_suffix(t_url, t_suffix);
 157
 158         MMPLAYER_FREEIF(t_url);
 159         MMPLAYER_FREEIF(t_suffix);
 160
 161         return ret;
 162 }
 163
 164 gboolean
 165 _mmplayer_post_message(mmplayer_t *player, enum MMMessageType msgtype, MMMessageParamType *param)
 166 {
 167         MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
 168
 169         if (!player->msg_cb)
 170                 return FALSE;
 171 #ifdef __DEBUG__
 172         LOGD("Message (type : %d)  will be posted using msg-cb(%p).", msgtype, player->msg_cb);
 173 #endif
 174
 175         player->msg_cb(msgtype, param, player->msg_cb_param);
 176
 177         return TRUE;
 178 }
 179
 180 gboolean
 181 _mmplayer_dump_pipeline_state(mmplayer_t *player)
 182 {
 183         GstIterator *iter = NULL;
 184         gboolean done = FALSE;
 185
 186         GValue item = {0, };
 187         GstElement *element = NULL;
 188         GstElementFactory *factory = NULL;
 189
 190         GstState state = GST_STATE_VOID_PENDING;
 191         GstState pending = GST_STATE_VOID_PENDING;
 192         GstClockTime time = 200 * GST_MSECOND;
 193
 194         MMPLAYER_FENTER();
 195
 196         MMPLAYER_RETURN_VAL_IF_FAIL(player &&
 197                 player->pipeline &&
 198                 player->pipeline->mainbin,
 199                 FALSE);
 200
 201         MMPLAYER_GENERATE_DOT_IF_ENABLED(player, "pipeline-status-error-dump");
 202
 203         iter = gst_bin_iterate_recurse(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst));
 204
 205         if (iter != NULL) {
 206                 while (!done) {
 207                         switch (gst_iterator_next(iter, &item)) {
 208                         case GST_ITERATOR_OK:
 209                                 element = g_value_get_object(&item);
 210                                 gst_element_get_state(element, &state, &pending, time);
 211
 212                                 factory = gst_element_get_factory(element) ;
 213                                 if (factory)
 214                                         LOGE("%s:%s : From:%s To:%s   refcount : %d", GST_OBJECT_NAME(factory) , GST_ELEMENT_NAME(element) ,
 215                                                 gst_element_state_get_name(state), gst_element_state_get_name(pending) , GST_OBJECT_REFCOUNT_VALUE(element));
 216                                 g_value_reset(&item);
 217                                 break;
 218                         case GST_ITERATOR_RESYNC:
 219                                 gst_iterator_resync(iter);
 220                                 break;
 221                         case GST_ITERATOR_ERROR:
 222                                 done = TRUE;
 223                                 break;
 224                         case GST_ITERATOR_DONE:
 225                                 done = TRUE;
 226                                 break;
 227                         }
 228                 }
 229         }
 230
 231         element = GST_ELEMENT(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst);
 232
 233         gst_element_get_state(element, &state, &pending, time);
 234
 235         factory = gst_element_get_factory(element) ;
 236
 237         if (factory) {
 238                 LOGE("%s:%s : From:%s To:%s  refcount : %d",
 239                         GST_OBJECT_NAME(factory),
 240                         GST_ELEMENT_NAME(element),
 241                         gst_element_state_get_name(state),
 242                         gst_element_state_get_name(pending),
 243                         GST_OBJECT_REFCOUNT_VALUE(element));
 244         }
 245
 246         g_value_unset(&item);
 247
 248         if (iter)
 249                 gst_iterator_free(iter);
 250
 251         MMPLAYER_FLEAVE();
 252
 253         return FALSE;
 254 }
 255
 256 int
 257 _mmplayer_exist_file_path(const char *file_path)
 258 {
 259         int fd = 0;
 260         struct stat stat_results = {0, };
 261
 262         if (!file_path || !strlen(file_path))
 263                 return MM_ERROR_PLAYER_FILE_NOT_FOUND;
 264
 265         fd = open(file_path, O_RDONLY);
 266
 267         if (fd < 0) {
 268                 char str_error[256];
 269                 strerror_r(errno, str_error, sizeof(str_error));
 270                 LOGE("failed to open file by %s (%d)", str_error, errno);
 271
 272                 if (EACCES == errno)
 273                         return MM_ERROR_PLAYER_PERMISSION_DENIED;
 274
 275                 return MM_ERROR_PLAYER_FILE_NOT_FOUND;
 276         }
 277
 278         if (fstat(fd, &stat_results) < 0) {
 279                 LOGE("failed to get file status");
 280         } else if (stat_results.st_size == 0) {
 281                 LOGE("file size is zero");
 282                 close(fd);
 283                 return MM_ERROR_PLAYER_FILE_NOT_FOUND;
 284         } else
 285                 LOGW("file size : %lld bytes", (long long)stat_results.st_size);
 286
 287         close(fd);
 288
 289         return MM_ERROR_NONE;
 290 }
 291
 292 char **
 293 _mmplayer_get_cookie_list(const char *cookies)
 294 {
 295         char **cookie_list = NULL;
 296         char *temp = NULL;
 297         gint i = 0;
 298
 299         if (!cookies || !strlen(cookies))
 300                 return NULL;
 301
 302         SECURE_LOGD("cookies : %zu[bytes] - %s", strlen(cookies), cookies);
 303
 304         temp = g_strdup(cookies);
 305
 306         /* trimming. it works inplace */
 307         g_strstrip(temp);
 308
 309         /* split */
 310         cookie_list = g_strsplit(temp, ";", 100);
 311
 312         if (!cookie_list) {
 313                 LOGE("failed to get cookie list");
 314                 goto EXIT;
 315         }
 316
 317         for (i = 0; i < g_strv_length(cookie_list); i++) {
 318                 if (cookie_list[i]) {
 319                         if (strlen(cookie_list[i])) {
 320                                 g_strstrip(cookie_list[i]);
 321                                 SECURE_LOGD("cookie_list[%d] : %zu[bytes] - %s", i, strlen(cookie_list[i]), cookie_list[i]);
 322                         } else {
 323                                 cookie_list[i][0] = '\0';
 324                         }
 325                 }
 326         }
 327
 328 EXIT:
 329         MMPLAYER_FREEIF(temp);
 330
 331         return cookie_list;
 332 }
 333
 334 /* check the given path is indicating sdp file */
 335 bool
 336 _mmplayer_is_sdp_file(const char *path)
 337 {
 338         gboolean ret = FALSE;
 339         gchar *uri = NULL;
 340
 341         MMPLAYER_FENTER();
 342
 343         MMPLAYER_RETURN_VAL_IF_FAIL(path, FALSE);
 344
 345         uri = g_ascii_strdown(path, -1);
 346
 347         if (uri == NULL)
 348                 return FALSE;
 349
 350         /* trimming */
 351         g_strstrip(uri);
 352
 353         /* strlen(".sdp") == 4 */
 354         if (strlen(uri) <= 4) {
 355                 LOGW("path is too short.");
 356                 MMPLAYER_FREEIF(uri);
 357                 return ret;
 358         }
 359
 360         /* first, check extension name */
 361         ret = g_str_has_suffix(uri, "sdp");
 362
 363         /* second, if no suffix is there, check it's contents */
 364         if (!ret)
 365                 /* FIXIT : do it soon */
 366                 LOGD("no suffix");
 367
 368         MMPLAYER_FREEIF(uri);
 369
 370         return ret;
 371 }
 372
 373 const char *
 374 _mmplayer_get_charset(const char *file_path)
 375 {
 376         UCharsetDetector *ucsd;
 377         const UCharsetMatch *ucm;
 378         UErrorCode status = U_ZERO_ERROR;
 379
 380         const char *charset = NULL;
 381         char *buf = NULL;
 382         FILE *fin = 0;
 383         size_t n_size = 0;
 384
 385         fin = fopen(file_path, "r");
 386         if (!fin) {
 387                 SECURE_LOGE("fail to open file %s", file_path);
 388                 return NULL;
 389         }
 390
 391         ucsd = ucsdet_open(&status);
 392         if (U_FAILURE(status)) {
 393                 LOGE("fail to ucsdet_open");
 394                 goto done;
 395         }
 396
 397         ucsdet_enableInputFilter(ucsd, TRUE);
 398
 399         buf = g_try_malloc(1024 * 1024);
 400         if (!buf) {
 401                 LOGE("fail to alloc");
 402                 goto done;
 403         }
 404
 405         n_size = fread(buf, 1, 1024*1024, fin);
 406         buf[1024 * 1024 - 1] = '\0';
 407         if (!n_size)
 408                 goto done;
 409
 410         ucsdet_setText(ucsd, buf, strlen(buf), &status);
 411         if (U_FAILURE(status)) {
 412                 LOGE("fail to ucsdet_setText");
 413                 goto done;
 414         }
 415
 416         ucm = ucsdet_detect(ucsd, &status);
 417         if (U_FAILURE(status)) {
 418                 LOGE("fail to ucsdet_detect");
 419                 goto done;
 420         }
 421
 422         charset = ucsdet_getName(ucm, &status);
 423         if (U_FAILURE(status)) {
 424                 LOGE("fail to ucsdet_getName");
 425                 goto done;
 426         }
 427
 428         /* CP949 encoding is an extension of the EUC-KR and it is backwards compatible.*/
 429         if (charset && !strcmp(charset, "EUC-KR"))
 430                 charset = "CP949";
 431
 432 done:
 433         if (fin)
 434                 fclose(fin);
 435
 436         if (ucsd)
 437                 ucsdet_close(ucsd);
 438
 439         MMPLAYER_FREEIF(buf);
 440
 441         return charset;
 442 }
 443
 444 int
 445 _mmplayer_get_pixtype(unsigned int fourcc)
 446 {
 447         int pixtype = MM_PIXEL_FORMAT_INVALID;
 448
 449 #ifdef __DEBUG__
 450         char *pfourcc = (char *)&fourcc;
 451
 452         LOGD("fourcc(%c%c%c%c)",
 453                 pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
 454 #endif
 455
 456         switch (fourcc) {
 457         case GST_MAKE_FOURCC('S', 'N', '1', '2'):
 458         case GST_MAKE_FOURCC('N', 'V', '1', '2'):
 459                 pixtype = MM_PIXEL_FORMAT_NV12;
 460                 break;
 461         case GST_MAKE_FOURCC('S', 'T', '1', '2'):
 462                 pixtype = MM_PIXEL_FORMAT_NV12T;
 463                 break;
 464         case GST_MAKE_FOURCC('S', 'N', '2', '1'):
 465         case GST_MAKE_FOURCC('N', 'V', '2', '1'):
 466                 pixtype = MM_PIXEL_FORMAT_NV21;
 467                 break;
 468         case GST_MAKE_FOURCC('S', 'U', 'Y', 'V'):
 469         case GST_MAKE_FOURCC('Y', 'U', 'Y', 'V'):
 470         case GST_MAKE_FOURCC('Y', 'U', 'Y', '2'):
 471                 pixtype = MM_PIXEL_FORMAT_YUYV;
 472                 break;
 473         case GST_MAKE_FOURCC('S', 'Y', 'V', 'Y'):
 474         case GST_MAKE_FOURCC('U', 'Y', 'V', 'Y'):
 475                 pixtype = MM_PIXEL_FORMAT_UYVY;
 476                 break;
 477         case GST_MAKE_FOURCC('S', '4', '2', '0'):
 478         case GST_MAKE_FOURCC('I', '4', '2', '0'):
 479                 pixtype = MM_PIXEL_FORMAT_I420;
 480                 break;
 481         case GST_MAKE_FOURCC('Y', 'V', '1', '2'):
 482                 pixtype = MM_PIXEL_FORMAT_YV12;
 483                 break;
 484         case GST_MAKE_FOURCC('4', '2', '2', 'P'):
 485                 pixtype = MM_PIXEL_FORMAT_422P;
 486                 break;
 487         case GST_MAKE_FOURCC('R', 'G', 'B', 'P'):
 488                 pixtype = MM_PIXEL_FORMAT_RGB565;
 489                 break;
 490         case GST_MAKE_FOURCC('R', 'G', 'B', '3'):
 491                 pixtype = MM_PIXEL_FORMAT_RGB888;
 492                 break;
 493         case GST_MAKE_FOURCC('A', 'R', 'G', 'B'):
 494         case GST_MAKE_FOURCC('x', 'R', 'G', 'B'):
 495                 pixtype = MM_PIXEL_FORMAT_ARGB;
 496                 break;
 497         case GST_MAKE_FOURCC('B', 'G', 'R', 'A'):
 498         case GST_MAKE_FOURCC('B', 'G', 'R', 'x'):
 499         case GST_MAKE_FOURCC('S', 'R', '3', '2'):
 500                 pixtype = MM_PIXEL_FORMAT_RGBA;
 501                 break;
 502         case GST_MAKE_FOURCC('J', 'P', 'E', 'G'):
 503         case GST_MAKE_FOURCC('P', 'N', 'G', ' '):
 504                 pixtype = MM_PIXEL_FORMAT_ENCODED;
 505                 break;
 506         case GST_MAKE_FOURCC('I', 'T', 'L', 'V'):
 507                 pixtype = MM_PIXEL_FORMAT_ITLV_JPEG_UYVY;
 508                 break;
 509         default:
 510                 LOGE("Not supported fourcc type(%c%c%c%c)",
 511                         fourcc, fourcc>>8, fourcc>>16, fourcc>>24);
 512                 pixtype = MM_PIXEL_FORMAT_INVALID;
 513                 break;
 514         }
 515
 516         return pixtype;
 517 }
 518
 519 static int
 520 __mmplayer_storage_supported_cb(int storage_id, storage_type_e type,
 521         storage_state_e state, const char *path, void *user_data)
 522 {
 523         mmplayer_storage_info_t *storage_info = (mmplayer_storage_info_t *)user_data;
 524
 525         MMPLAYER_RETURN_VAL_IF_FAIL(storage_info, FALSE);
 526
 527         if (type == storage_info->type && strstr(storage_info->path, path)) {
 528                 storage_info->id = storage_id;
 529                 storage_info->state = state;
 530                 return FALSE;
 531         }
 532
 533         return TRUE;
 534 }
 535
 536 bool
 537 _mmplayer_get_storage_info(const char *path, mmplayer_storage_info_t *storage_info)
 538 {
 539         int ret = 0;
 540         const char *file_path = path;
 541
 542         MMPLAYER_RETURN_VAL_IF_FAIL(file_path && storage_info, false);
 543
 544         if (strncmp(file_path, "file://", strlen("file://")) == 0)
 545                 file_path = path + 7; /* remove file prefix */
 546
 547         if (strncmp(file_path, MEDIA_PATH_EXTERNAL, strlen(MEDIA_PATH_EXTERNAL)) == 0) {
 548                 storage_info->type = STORAGE_TYPE_EXTERNAL;
 549
 550                 memset(storage_info->path, 0x00, MM_MAX_URL_LEN);
 551                 g_snprintf(storage_info->path, MM_MAX_URL_LEN, "%s", file_path);
 552
 553                 ret = storage_foreach_device_supported((storage_device_supported_cb)__mmplayer_storage_supported_cb, storage_info);
 554                 if (ret != STORAGE_ERROR_NONE) {
 555                         LOGE("failed to check supported storage 0x%x", ret);
 556                         return false;
 557                 }
 558
 559                 if (storage_info->state <= STORAGE_STATE_REMOVED) {
 560                         LOGE("need to check the external storage state %d:%d", storage_info->id, storage_info->state);
 561                         return false;
 562                 }
 563         } else {
 564                 storage_info->type = STORAGE_TYPE_INTERNAL;
 565                 storage_info->state = STORAGE_STATE_MOUNTED;
 566         }
 567
 568         LOGD("storage info %d:%d:%d", storage_info->type, storage_info->id, storage_info->state);
 569         return true;
 570 }
 571
 572 media_format_mimetype_e _mmplayer_convert_audio_pcm_str_to_media_format_mime(const gchar *audio_pcm_str)
 573 {
 574         if (!audio_pcm_str) {
 575                 LOGW("audio pcm str is NULL");
 576                 return MEDIA_FORMAT_MAX;
 577         }
 578
 579         if (strstr(audio_pcm_str, "S16LE"))
 580                 return MEDIA_FORMAT_PCM_S16LE;
 581         else if (strstr(audio_pcm_str, "S24LE"))
 582                 return MEDIA_FORMAT_PCM_S24LE;
 583         else if (strstr(audio_pcm_str, "S32LE"))
 584                 return MEDIA_FORMAT_PCM_S32LE;
 585         else if (strstr(audio_pcm_str, "S16BE"))
 586                 return MEDIA_FORMAT_PCM_S16BE;
 587         else if (strstr(audio_pcm_str, "S24BE"))
 588                 return MEDIA_FORMAT_PCM_S24BE;
 589         else if (strstr(audio_pcm_str, "S32BE"))
 590                 return MEDIA_FORMAT_PCM_S32BE;
 591         else if (strstr(audio_pcm_str, "F32LE"))
 592                 return MEDIA_FORMAT_PCM_F32LE;
 593         else if (strstr(audio_pcm_str, "F32BE"))
 594                 return MEDIA_FORMAT_PCM_F32BE;
 595         else if (strstr(audio_pcm_str, "U16LE"))
 596                 return MEDIA_FORMAT_PCM_U16LE;
 597         else if (strstr(audio_pcm_str, "U24LE"))
 598                 return MEDIA_FORMAT_PCM_U24LE;
 599         else if (strstr(audio_pcm_str, "U32LE"))
 600                 return MEDIA_FORMAT_PCM_U32LE;
 601         else if (strstr(audio_pcm_str, "U16BE"))
 602                 return MEDIA_FORMAT_PCM_U16BE;
 603         else if (strstr(audio_pcm_str, "U24BE"))
 604                 return MEDIA_FORMAT_PCM_U24BE;
 605         else if (strstr(audio_pcm_str, "U32BE"))
 606                 return MEDIA_FORMAT_PCM_U32BE;
 607         else {
 608                 LOGW("Not supported audio pcm format str : %s", audio_pcm_str);
 609                 return MEDIA_FORMAT_MAX;
 610         }
 611 }