Blame view

trunk/src/libs/srs_librtmp.cpp 21.8 KB
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
The MIT License (MIT)

Copyright (c) 2013-2014 winlin

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include <srs_librtmp.hpp>

#include <stdlib.h>

#include <string>
29
#include <sstream>
30 31 32 33 34 35 36
using namespace std;

#include <srs_kernel_error.hpp>
#include <srs_protocol_rtmp.hpp>
#include <srs_lib_simple_socket.hpp>
#include <srs_kernel_log.hpp>
#include <srs_protocol_utility.hpp>
37 38
#include <srs_core_autofree.hpp>
#include <srs_protocol_rtmp_stack.hpp>
39
#include <srs_kernel_utility.hpp>
40 41
#include <srs_kernel_stream.hpp>
#include <srs_protocol_amf0.hpp>
42
#include <srs_kernel_flv.hpp>
winlin authored
43
#include <srs_kernel_codec.hpp>
44
#include <srs_kernel_file.hpp>
45 46 47

// if user want to define log, define the folowing macro.
#ifndef SRS_RTMP_USER_DEFINED_LOG
48 49 50
    // kernel module.
    ISrsLog* _srs_log = new ISrsLog();
    ISrsThreadContext* _srs_context = new ISrsThreadContext();
51 52 53 54 55 56 57
#endif

/**
* export runtime context.
*/
struct Context
{
58 59 60
    std::string url;
    std::string tcUrl;
    std::string host;
winlin authored
61
    std::string ip;
62 63 64 65 66
    std::string port;
    std::string vhost;
    std::string app;
    std::string stream;
    
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
    SrsRtmpClient* rtmp;
    SimpleSocketStream* skt;
    int stream_id;
    
    Context() {
        rtmp = NULL;
        skt = NULL;
        stream_id = 0;
    }
    virtual ~Context() {
        srs_freep(rtmp);
        srs_freep(skt);
    }
};
winlin authored
82
int srs_librtmp_context_parse_uri(Context* context) 
83
{
84
    int ret = ERROR_SUCCESS;
85 86
    
    // parse uri
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
    size_t pos = string::npos;
    string uri = context->url;
    // tcUrl, stream
    if ((pos = uri.rfind("/")) != string::npos) {
        context->stream = uri.substr(pos + 1);
        context->tcUrl = uri = uri.substr(0, pos);
    }
    // schema
    if ((pos = uri.find("rtmp://")) != string::npos) {
        uri = uri.substr(pos + 7);
    }
    // host/vhost/port
    if ((pos = uri.find(":")) != string::npos) {
        context->vhost = context->host = uri.substr(0, pos);
        uri = uri.substr(pos + 1);
        
        if ((pos = uri.find("/")) != string::npos) {
            context->port = uri.substr(0, pos);
            uri = uri.substr(pos + 1);
        }
    } else {
        if ((pos = uri.find("/")) != string::npos) {
            context->vhost = context->host = uri.substr(0, pos);
            uri = uri.substr(pos + 1);
        }
        context->port = RTMP_DEFAULT_PORT;
    }
    // app
    context->app = uri;
    // query of app
    if ((pos = uri.find("?")) != string::npos) {
        context->app = uri.substr(0, pos);
        string query = uri.substr(pos + 1);
        if ((pos = query.find("vhost=")) != string::npos) {
            context->vhost = query.substr(pos + 6);
            if ((pos = context->vhost.find("&")) != string::npos) {
                context->vhost = context->vhost.substr(pos);
            }
        }
    }
127
    
winlin authored
128 129 130 131 132 133 134
    return ret;
}

int srs_librtmp_context_resolve_host(Context* context) 
{
    int ret = ERROR_SUCCESS;
    
135
    // create socket
136 137 138 139 140 141 142 143
    srs_freep(context->skt);
    context->skt = new SimpleSocketStream();
    
    if ((ret = context->skt->create_socket()) != ERROR_SUCCESS) {
        return ret;
    }
    
    // connect to server:port
winlin authored
144 145
    context->ip = srs_dns_resolve(context->host);
    if (context->ip.empty()) {
146 147
        return -1;
    }
winlin authored
148 149 150 151 152 153 154 155 156 157 158 159 160 161
    
    return ret;
}

int srs_librtmp_context_connect(Context* context) 
{
    int ret = ERROR_SUCCESS;
    
    srs_assert(context->skt);
    
    std::string ip = context->ip;
    int port = ::atoi(context->port.c_str());
    
    if ((ret = context->skt->connect(ip.c_str(), port)) != ERROR_SUCCESS) {
162 163 164 165
        return ret;
    }
    
    return ret;
166 167 168 169 170 171 172 173 174
}

#ifdef __cplusplus
extern "C"{
#endif

srs_rtmp_t srs_rtmp_create(const char* url)
{
    Context* context = new Context();
175
    context->url = url;
176 177 178 179 180 181 182 183 184 185 186 187 188
    return context;
}

void srs_rtmp_destroy(srs_rtmp_t rtmp)
{
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    
    srs_freep(context);
}

int srs_simple_handshake(srs_rtmp_t rtmp)
{
189 190
    int ret = ERROR_SUCCESS;
    
winlin authored
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
    if ((ret = __srs_dns_resolve(rtmp)) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = __srs_connect_server(rtmp)) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = __srs_do_simple_handshake(rtmp)) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
}

int __srs_dns_resolve(srs_rtmp_t rtmp)
{
    int ret = ERROR_SUCCESS;
    
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    
    // parse uri
    if ((ret = srs_librtmp_context_parse_uri(context)) != ERROR_SUCCESS) {
        return ret;
    }
    // resolve host
    if ((ret = srs_librtmp_context_resolve_host(context)) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
}

int __srs_connect_server(srs_rtmp_t rtmp)
{
    int ret = ERROR_SUCCESS;
    
229 230 231 232 233 234
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    
    if ((ret = srs_librtmp_context_connect(context)) != ERROR_SUCCESS) {
        return ret;
    }
235
    
winlin authored
236 237 238 239 240 241 242 243 244 245 246 247
    return ret;
}

int __srs_do_simple_handshake(srs_rtmp_t rtmp)
{
    int ret = ERROR_SUCCESS;
    
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    
    srs_assert(context->skt != NULL);
    
248 249 250 251 252 253 254 255 256
    // simple handshake
    srs_freep(context->rtmp);
    context->rtmp = new SrsRtmpClient(context->skt);
    
    if ((ret = context->rtmp->simple_handshake()) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
257 258 259 260
}

int srs_connect_app(srs_rtmp_t rtmp)
{
261 262
    int ret = ERROR_SUCCESS;
    
263 264
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
265
    
266
    string tcUrl = srs_generate_tc_url(context->ip, context->vhost, context->app, context->port);
267 268 269 270 271
    if ((ret = context->rtmp->connect_app(context->app, tcUrl)) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
272 273 274 275
}

int srs_play_stream(srs_rtmp_t rtmp)
{
276 277
    int ret = ERROR_SUCCESS;
    
278 279 280 281 282 283 284 285 286 287
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    
    if ((ret = context->rtmp->create_stream(context->stream_id)) != ERROR_SUCCESS) {
        return ret;
    }
    if ((ret = context->rtmp->play(context->stream, context->stream_id)) != ERROR_SUCCESS) {
        return ret;
    }
    
288
    return ret;
289 290 291 292
}

int srs_publish_stream(srs_rtmp_t rtmp)
{
293 294
    int ret = ERROR_SUCCESS;
    
295 296 297
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    
298 299 300 301
    if ((ret = context->rtmp->fmle_publish(context->stream, context->stream_id)) != ERROR_SUCCESS) {
        return ret;
    }
    
302
    return ret;
303 304
}
305 306
const char* srs_type2string(int type)
{
307 308 309 310 311
    static const char* audio = "Audio";
    static const char* video = "Video";
    static const char* data = "Data";
    static const char* unknown = "Unknown";
    
312
    switch (type) {
313 314 315 316
        case SRS_RTMP_TYPE_AUDIO: return audio;
        case SRS_RTMP_TYPE_VIDEO: return video;
        case SRS_RTMP_TYPE_SCRIPT: return data;
        default: return unknown;
317 318
    }
    
319
    return unknown;
320 321 322 323
}

int srs_read_packet(srs_rtmp_t rtmp, int* type, u_int32_t* timestamp, char** data, int* size)
{
324 325 326 327 328 329 330
    *type = 0;
    *timestamp = 0;
    *data = NULL;
    *size = 0;
    
    int ret = ERROR_SUCCESS;
    
331 332 333 334
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    
    for (;;) {
335 336
        SrsMessage* msg = NULL;
        if ((ret = context->rtmp->recv_message(&msg)) != ERROR_SUCCESS) {
337 338 339 340 341 342
            return ret;
        }
        if (!msg) {
            continue;
        }
        
343
        SrsAutoFree(SrsMessage, msg);
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
        
        if (msg->header.is_audio()) {
            *type = SRS_RTMP_TYPE_AUDIO;
            *timestamp = (u_int32_t)msg->header.timestamp;
            *data = (char*)msg->payload;
            *size = (int)msg->size;
            // detach bytes from packet.
            msg->payload = NULL;
        } else if (msg->header.is_video()) {
            *type = SRS_RTMP_TYPE_VIDEO;
            *timestamp = (u_int32_t)msg->header.timestamp;
            *data = (char*)msg->payload;
            *size = (int)msg->size;
            // detach bytes from packet.
            msg->payload = NULL;
        } else if (msg->header.is_amf0_data() || msg->header.is_amf3_data()) {
            *type = SRS_RTMP_TYPE_SCRIPT;
            *data = (char*)msg->payload;
            *size = (int)msg->size;
            // detach bytes from packet.
            msg->payload = NULL;
        } else {
            // ignore and continue
            continue;
        }
        
        // got expected message.
        break;
    }
    
374
    return ret;
375 376 377 378
}

int srs_write_packet(srs_rtmp_t rtmp, int type, u_int32_t timestamp, char* data, int size)
{
379 380
    int ret = ERROR_SUCCESS;
    
381 382
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
383
    
384
    SrsSharedPtrMessage* msg = NULL;
385 386 387 388 389
    
    if (type == SRS_RTMP_TYPE_AUDIO) {
        SrsMessageHeader header;
        header.initialize_audio(size, timestamp, context->stream_id);
        
390
        msg = new SrsSharedPtrMessage();
391
        if ((ret = msg->create(&header, data, size)) != ERROR_SUCCESS) {
392
            srs_freep(data);
393 394 395 396 397 398
            return ret;
        }
    } else if (type == SRS_RTMP_TYPE_VIDEO) {
        SrsMessageHeader header;
        header.initialize_video(size, timestamp, context->stream_id);
        
399
        msg = new SrsSharedPtrMessage();
400
        if ((ret = msg->create(&header, data, size)) != ERROR_SUCCESS) {
401
            srs_freep(data);
402 403 404 405 406 407
            return ret;
        }
    } else if (type == SRS_RTMP_TYPE_SCRIPT) {
        SrsMessageHeader header;
        header.initialize_amf0_script(size, context->stream_id);
        
408
        msg = new SrsSharedPtrMessage();
409
        if ((ret = msg->create(&header, data, size)) != ERROR_SUCCESS) {
410
            srs_freep(data);
411 412 413 414 415 416
            return ret;
        }
    }
    
    if (msg) {
        // send out encoded msg.
417
        if ((ret = context->rtmp->send_and_free_message(msg, context->stream_id)) != ERROR_SUCCESS) {
418 419 420 421
            return ret;
        }
    } else {
        // directly free data if not sent out.
422
        srs_freep(data);
423 424 425
    }
    
    return ret;
426 427
}
428 429
int srs_version_major()
{
430
    return ::atoi(VERSION_MAJOR);
431 432 433 434
}

int srs_version_minor()
{
435
    return ::atoi(VERSION_MINOR);
436 437 438 439
}

int srs_version_revision()
{
440
    return ::atoi(VERSION_REVISION);
441 442
}
443 444 445 446 447 448
int64_t srs_get_time_ms()
{
    srs_update_system_time_ms();
    return srs_get_system_time_ms();
}
449 450 451 452 453 454 455 456 457 458 459 460 461 462
int64_t srs_get_nsend_bytes(srs_rtmp_t rtmp)
{
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    return context->rtmp->get_send_bytes();
}

int64_t srs_get_nrecv_bytes(srs_rtmp_t rtmp)
{
    srs_assert(rtmp != NULL);
    Context* context = (Context*)rtmp;
    return context->rtmp->get_recv_bytes();
}
463 464
struct FlvContext
{
465 466
    SrsFileReader reader;
    SrsFileWriter writer;
467 468 469 470
    SrsFlvEncoder enc;
    SrsFlvDecoder dec;
};
471
srs_flv_t srs_flv_open_read(const char* file)
472 473 474 475 476
{
    int ret = ERROR_SUCCESS;
    
    FlvContext* flv = new FlvContext();
    
477
    if ((ret = flv->reader.open(file)) != ERROR_SUCCESS) {
478 479 480 481
        srs_freep(flv);
        return NULL;
    }
    
482
    if ((ret = flv->dec.initialize(&flv->reader)) != ERROR_SUCCESS) {
483 484 485 486
        srs_freep(flv);
        return NULL;
    }
    
487 488 489 490 491 492 493 494 495 496
    return flv;
}

srs_flv_t srs_flv_open_write(const char* file)
{
    int ret = ERROR_SUCCESS;
    
    FlvContext* flv = new FlvContext();
    
    if ((ret = flv->writer.open(file)) != ERROR_SUCCESS) {
497 498 499 500
        srs_freep(flv);
        return NULL;
    }
    
501
    if ((ret = flv->enc.initialize(&flv->writer)) != ERROR_SUCCESS) {
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
        srs_freep(flv);
        return NULL;
    }
    
    return flv;
}

void srs_flv_close(srs_flv_t flv)
{
    FlvContext* context = (FlvContext*)flv;
    srs_freep(context);
}

int srs_flv_read_header(srs_flv_t flv, char header[9])
{
    int ret = ERROR_SUCCESS;
    
    FlvContext* context = (FlvContext*)flv;
520 521 522 523 524

    if (!context->reader.is_open()) {
        return ERROR_SYSTEM_IO_INVALID;
    }
    
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
    if ((ret = context->dec.read_header(header)) != ERROR_SUCCESS) {
        return ret;
    }
    
    char ts[4]; // tag size
    if ((ret = context->dec.read_previous_tag_size(ts)) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
}

int srs_flv_read_tag_header(srs_flv_t flv, char* ptype, int32_t* pdata_size, u_int32_t* ptime)
{
    int ret = ERROR_SUCCESS;
    
    FlvContext* context = (FlvContext*)flv;
542 543 544 545 546

    if (!context->reader.is_open()) {
        return ERROR_SYSTEM_IO_INVALID;
    }
    
547 548 549 550 551 552 553 554 555 556 557 558
    if ((ret = context->dec.read_tag_header(ptype, pdata_size, ptime)) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
}

int srs_flv_read_tag_data(srs_flv_t flv, char* data, int32_t size)
{
    int ret = ERROR_SUCCESS;
    
    FlvContext* context = (FlvContext*)flv;
559 560 561 562 563

    if (!context->reader.is_open()) {
        return ERROR_SYSTEM_IO_INVALID;
    }
    
564 565 566 567 568 569 570 571 572 573 574 575
    if ((ret = context->dec.read_tag_data(data, size)) != ERROR_SUCCESS) {
        return ret;
    }
    
    char ts[4]; // tag size
    if ((ret = context->dec.read_previous_tag_size(ts)) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
}
winlin authored
576 577 578 579 580
int srs_flv_write_header(srs_flv_t flv, char header[9])
{
    int ret = ERROR_SUCCESS;
    
    FlvContext* context = (FlvContext*)flv;
581 582 583 584 585

    if (!context->writer.is_open()) {
        return ERROR_SYSTEM_IO_INVALID;
    }
    
winlin authored
586 587 588 589 590 591 592 593 594 595 596 597
    if ((ret = context->enc.write_header(header)) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
}

int srs_flv_write_tag(srs_flv_t flv, char type, int32_t time, char* data, int size)
{
    int ret = ERROR_SUCCESS;
    
    FlvContext* context = (FlvContext*)flv;
598 599 600 601 602

    if (!context->writer.is_open()) {
        return ERROR_SYSTEM_IO_INVALID;
    }
    
winlin authored
603 604 605 606 607 608 609 610 611 612 613
    if (type == SRS_RTMP_TYPE_AUDIO) {
        return context->enc.write_audio(time, data, size);
    } else if (type == SRS_RTMP_TYPE_VIDEO) {
        return context->enc.write_video(time, data, size);
    } else {
        return context->enc.write_metadata(data, size);
    }

    return ret;
}
614 615 616 617 618
int srs_flv_size_tag(int data_size)
{
    return SrsFlvEncoder::size_tag(data_size);
}
619 620 621
int64_t srs_flv_tellg(srs_flv_t flv)
{
    FlvContext* context = (FlvContext*)flv;
622
    return context->reader.tellg();
623 624
}
winlin authored
625 626 627
void srs_flv_lseek(srs_flv_t flv, int64_t offset)
{
    FlvContext* context = (FlvContext*)flv;
628
    context->reader.lseek(offset);
winlin authored
629 630
}
631 632 633 634 635
flv_bool srs_flv_is_eof(int error_code)
{
    return error_code == ERROR_SYSTEM_FILE_EOF;
}
winlin authored
636 637
flv_bool srs_flv_is_sequence_header(char* data, int32_t size)
{
638
    return SrsFlvCodec::video_is_sequence_header((int8_t*)data, (int)size);
winlin authored
639 640 641 642
}

flv_bool srs_flv_is_keyframe(char* data, int32_t size)
{
643
    return SrsFlvCodec::video_is_keyframe((int8_t*)data, (int)size);
winlin authored
644 645
}
646
srs_amf0_t srs_amf0_parse(char* data, int size, int* nparsed)
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
{
    int ret = ERROR_SUCCESS;
    
    srs_amf0_t amf0 = NULL;
    
    SrsStream stream;
    if ((ret = stream.initialize(data, size)) != ERROR_SUCCESS) {
        return amf0;
    }
    
    SrsAmf0Any* any = NULL;
    if ((ret = SrsAmf0Any::discovery(&stream, &any)) != ERROR_SUCCESS) {
        return amf0;
    }
    
662
    stream.skip(-1 * stream.pos());
663 664 665 666 667
    if ((ret = any->read(&stream)) != ERROR_SUCCESS) {
        srs_freep(any);
        return amf0;
    }
    
668
    *nparsed = stream.pos();
669 670 671 672 673
    amf0 = (srs_amf0_t)any;
    
    return amf0;
}
winlin authored
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
srs_amf0_t srs_amf0_create_number(amf0_number value)
{
    return SrsAmf0Any::number(value);
}

srs_amf0_t srs_amf0_create_ecma_array()
{
    return SrsAmf0Any::ecma_array();
}

srs_amf0_t srs_amf0_create_strict_array()
{
    return SrsAmf0Any::strict_array();
}
winlin authored
689 690 691 692 693
srs_amf0_t srs_amf0_create_object()
{
    return SrsAmf0Any::object();
}
694 695 696 697 698 699 700 701 702 703 704
void srs_amf0_free(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_freep(any);
}

void srs_amf0_free_bytes(char* data)
{
    srs_freep(data);
}
winlin authored
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
int srs_amf0_size(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->total_size();
}

int srs_amf0_serialize(srs_amf0_t amf0, char* data, int size)
{
    int ret = ERROR_SUCCESS;
    
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    
    SrsStream stream;
    if ((ret = stream.initialize(data, size)) != ERROR_SUCCESS) {
        return ret;
    }
    
    if ((ret = any->write(&stream)) != ERROR_SUCCESS) {
        return ret;
    }
    
    return ret;
}
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
amf0_bool srs_amf0_is_string(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->is_string();
}

amf0_bool srs_amf0_is_boolean(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->is_boolean();
}

amf0_bool srs_amf0_is_number(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->is_number();
}

amf0_bool srs_amf0_is_null(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->is_null();
}

amf0_bool srs_amf0_is_object(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->is_object();
}

amf0_bool srs_amf0_is_ecma_array(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->is_ecma_array();
}
765 766 767 768 769 770
amf0_bool srs_amf0_is_strict_array(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->is_strict_array();
}
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
const char* srs_amf0_to_string(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->to_str_raw();
}

amf0_bool srs_amf0_to_boolean(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->to_boolean();
}

amf0_number srs_amf0_to_number(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    return any->to_number();
}
789 790 791 792 793 794
void srs_amf0_set_number(srs_amf0_t amf0, amf0_number value)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    any->set_number(value);
}
795 796
int srs_amf0_object_property_count(srs_amf0_t amf0)
{
winlin authored
797 798 799
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_object());
800 801 802 803 804 805
    SrsAmf0Object* obj = (SrsAmf0Object*)amf0;
    return obj->count();
}

const char* srs_amf0_object_property_name_at(srs_amf0_t amf0, int index)
{
winlin authored
806 807 808
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_object());
809 810 811 812 813 814
    SrsAmf0Object* obj = (SrsAmf0Object*)amf0;
    return obj->key_raw_at(index);
}

srs_amf0_t srs_amf0_object_property_value_at(srs_amf0_t amf0, int index)
{
winlin authored
815 816 817
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_object());
818 819 820 821
    SrsAmf0Object* obj = (SrsAmf0Object*)amf0;
    return (srs_amf0_t)obj->value_at(index);
}
winlin authored
822 823
srs_amf0_t srs_amf0_object_property(srs_amf0_t amf0, const char* name)
{
winlin authored
824 825 826
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_object());
winlin authored
827 828 829 830 831 832
    SrsAmf0Object* obj = (SrsAmf0Object*)amf0;
    return (srs_amf0_t)obj->get_property(name);
}

void srs_amf0_object_property_set(srs_amf0_t amf0, const char* name, srs_amf0_t value)
{
winlin authored
833 834 835
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_object());
winlin authored
836
    SrsAmf0Object* obj = (SrsAmf0Object*)amf0;
winlin authored
837
    any = (SrsAmf0Any*)value;
winlin authored
838 839 840
    obj->set(name, any);
}
winlin authored
841 842 843 844 845 846 847 848 849
void srs_amf0_object_clear(srs_amf0_t amf0)
{
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_object());

    SrsAmf0Object* obj = (SrsAmf0Object*)amf0;
    obj->clear();
}
850
int srs_amf0_ecma_array_property_count(srs_amf0_t amf0)
851
{
winlin authored
852 853 854
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_ecma_array());
855 856 857 858
    SrsAmf0EcmaArray * obj = (SrsAmf0EcmaArray*)amf0;
    return obj->count();
}
859
const char* srs_amf0_ecma_array_property_name_at(srs_amf0_t amf0, int index)
860
{
winlin authored
861 862 863
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_ecma_array());
864 865 866 867
    SrsAmf0EcmaArray* obj = (SrsAmf0EcmaArray*)amf0;
    return obj->key_raw_at(index);
}
868
srs_amf0_t srs_amf0_ecma_array_property_value_at(srs_amf0_t amf0, int index)
869
{
winlin authored
870 871 872
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_ecma_array());
873 874 875 876
    SrsAmf0EcmaArray* obj = (SrsAmf0EcmaArray*)amf0;
    return (srs_amf0_t)obj->value_at(index);
}
winlin authored
877 878
srs_amf0_t srs_amf0_ecma_array_property(srs_amf0_t amf0, const char* name)
{
winlin authored
879 880 881
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_ecma_array());
winlin authored
882 883 884 885 886 887
    SrsAmf0EcmaArray* obj = (SrsAmf0EcmaArray*)amf0;
    return (srs_amf0_t)obj->get_property(name);
}

void srs_amf0_ecma_array_property_set(srs_amf0_t amf0, const char* name, srs_amf0_t value)
{
winlin authored
888 889
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_ecma_array());
winlin authored
890
891
    SrsAmf0EcmaArray* obj = (SrsAmf0EcmaArray*)amf0;
winlin authored
892 893
    any = (SrsAmf0Any*)value;
    obj->set(name, any);
894 895
}
896
int srs_amf0_strict_array_property_count(srs_amf0_t amf0)
897
{
winlin authored
898 899 900
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_strict_array());
winlin authored
901
    SrsAmf0StrictArray * obj = (SrsAmf0StrictArray*)amf0;
902 903 904 905 906
    return obj->count();
}

srs_amf0_t srs_amf0_strict_array_property_at(srs_amf0_t amf0, int index)
{
winlin authored
907 908 909
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_strict_array());
winlin authored
910 911 912 913 914 915
    SrsAmf0StrictArray* obj = (SrsAmf0StrictArray*)amf0;
    return (srs_amf0_t)obj->at(index);
}

void srs_amf0_strict_array_append(srs_amf0_t amf0, srs_amf0_t value)
{
winlin authored
916 917 918
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    srs_assert(any->is_strict_array());
winlin authored
919
    SrsAmf0StrictArray* obj = (SrsAmf0StrictArray*)amf0;
winlin authored
920
    any = (SrsAmf0Any*)value;
winlin authored
921
    obj->append(any);
922 923
}
924 925
char* srs_amf0_human_print(srs_amf0_t amf0, char** pdata, int* psize)
{
926 927 928 929
    if (!amf0) {
        return NULL;
    }
    
930 931
    SrsAmf0Any* any = (SrsAmf0Any*)amf0;
    
932
    return any->human_print(pdata, psize);
933 934
}
935 936 937
#ifdef __cplusplus
}
#endif